/* Generated by Cython 3.2.2 */

/* BEGIN: Cython Metadata
{
    "distutils": {
        "depends": [],
        "extra_compile_args": [
            "-std=c++14",
            "-fpermissive",
            "-Wno-deprecated-declarations",
            "-fno-var-tracking-assignments",
            "-O3"
        ],
        "include_dirs": [
            "/opt/python/cp310-cp310/include",
            "/host//home/runner/_work/cuda-python/cuda-python/cuda_toolkit/include"
        ],
        "language": "c++",
        "library_dirs": [
            "/tmp/build-env-yyn641v7/lib/python3.10/site-packages",
            "/tmp/build-env-yyn641v7/lib",
            "/host//home/runner/_work/cuda-python/cuda-python/cuda_toolkit/lib64",
            "/host//home/runner/_work/cuda-python/cuda-python/cuda_toolkit/lib"
        ],
        "name": "cuda.bindings._internal._nvml",
        "sources": [
            "cuda/bindings/_internal/_nvml.pyx"
        ]
    },
    "module_name": "cuda.bindings._internal._nvml"
}
END: Cython Metadata */

#ifndef PY_SSIZE_T_CLEAN
#define PY_SSIZE_T_CLEAN
#endif /* PY_SSIZE_T_CLEAN */
/* InitLimitedAPI */
#if defined(Py_LIMITED_API)
  #if !defined(CYTHON_LIMITED_API)
  #define CYTHON_LIMITED_API 1
  #endif
#elif defined(CYTHON_LIMITED_API)
  #ifdef _MSC_VER
  #pragma message ("Limited API usage is enabled with 'CYTHON_LIMITED_API' but 'Py_LIMITED_API' does not define a Python target version. Consider setting 'Py_LIMITED_API' instead.")
  #else
  #warning Limited API usage is enabled with 'CYTHON_LIMITED_API' but 'Py_LIMITED_API' does not define a Python target version. Consider setting 'Py_LIMITED_API' instead.
  #endif
#endif

#include "Python.h"
#ifndef Py_PYTHON_H
    #error Python headers needed to compile C extensions, please install development version of Python.
#elif PY_VERSION_HEX < 0x03080000
    #error Cython requires Python 3.8+.
#else
#define __PYX_ABI_VERSION "3_2_2"
#define CYTHON_HEX_VERSION 0x030202F0
#define CYTHON_FUTURE_DIVISION 1
/* CModulePreamble */
#include <stddef.h>
#ifndef offsetof
  #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
#endif
#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS)
  #ifndef __stdcall
    #define __stdcall
  #endif
  #ifndef __cdecl
    #define __cdecl
  #endif
  #ifndef __fastcall
    #define __fastcall
  #endif
#endif
#ifndef DL_IMPORT
  #define DL_IMPORT(t) t
#endif
#ifndef DL_EXPORT
  #define DL_EXPORT(t) t
#endif
#define __PYX_COMMA ,
#ifndef PY_LONG_LONG
  #define PY_LONG_LONG LONG_LONG
#endif
#ifndef Py_HUGE_VAL
  #define Py_HUGE_VAL HUGE_VAL
#endif
#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX
#if defined(GRAALVM_PYTHON)
  /* For very preliminary testing purposes. Most variables are set the same as PyPy.
     The existence of this section does not imply that anything works or is even tested */
  #define CYTHON_COMPILING_IN_PYPY 0
  #define CYTHON_COMPILING_IN_CPYTHON 0
  #define CYTHON_COMPILING_IN_LIMITED_API 0
  #define CYTHON_COMPILING_IN_GRAAL 1
  #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0
  #undef CYTHON_USE_TYPE_SLOTS
  #define CYTHON_USE_TYPE_SLOTS 0
  #undef CYTHON_USE_TYPE_SPECS
  #define CYTHON_USE_TYPE_SPECS 0
  #undef CYTHON_USE_PYTYPE_LOOKUP
  #define CYTHON_USE_PYTYPE_LOOKUP 0
  #undef CYTHON_USE_PYLIST_INTERNALS
  #define CYTHON_USE_PYLIST_INTERNALS 0
  #undef CYTHON_USE_UNICODE_INTERNALS
  #define CYTHON_USE_UNICODE_INTERNALS 0
  #undef CYTHON_USE_UNICODE_WRITER
  #define CYTHON_USE_UNICODE_WRITER 0
  #undef CYTHON_USE_PYLONG_INTERNALS
  #define CYTHON_USE_PYLONG_INTERNALS 0
  #undef CYTHON_AVOID_BORROWED_REFS
  #define CYTHON_AVOID_BORROWED_REFS 1
  #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
  #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0
  #undef CYTHON_ASSUME_SAFE_MACROS
  #define CYTHON_ASSUME_SAFE_MACROS 0
  #undef CYTHON_ASSUME_SAFE_SIZE
  #define CYTHON_ASSUME_SAFE_SIZE 0
  #undef CYTHON_UNPACK_METHODS
  #define CYTHON_UNPACK_METHODS 0
  #undef CYTHON_FAST_THREAD_STATE
  #define CYTHON_FAST_THREAD_STATE 0
  #undef CYTHON_FAST_GIL
  #define CYTHON_FAST_GIL 0
  #undef CYTHON_METH_FASTCALL
  #define CYTHON_METH_FASTCALL 0
  #undef CYTHON_FAST_PYCALL
  #define CYTHON_FAST_PYCALL 0
  #ifndef CYTHON_PEP487_INIT_SUBCLASS
    #define CYTHON_PEP487_INIT_SUBCLASS 1
  #endif
  #undef CYTHON_PEP489_MULTI_PHASE_INIT
  #define CYTHON_PEP489_MULTI_PHASE_INIT 1
  #undef CYTHON_USE_MODULE_STATE
  #define CYTHON_USE_MODULE_STATE 0
  #undef CYTHON_USE_SYS_MONITORING
  #define CYTHON_USE_SYS_MONITORING 0
  #undef CYTHON_USE_TP_FINALIZE
  #define CYTHON_USE_TP_FINALIZE 0
  #undef CYTHON_USE_AM_SEND
  #define CYTHON_USE_AM_SEND 0
  #undef CYTHON_USE_DICT_VERSIONS
  #define CYTHON_USE_DICT_VERSIONS 0
  #undef CYTHON_USE_EXC_INFO_STACK
  #define CYTHON_USE_EXC_INFO_STACK 1
  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
  #endif
  #undef CYTHON_USE_FREELISTS
  #define CYTHON_USE_FREELISTS 0
  #undef CYTHON_IMMORTAL_CONSTANTS
  #define CYTHON_IMMORTAL_CONSTANTS 0
#elif defined(PYPY_VERSION)
  #define CYTHON_COMPILING_IN_PYPY 1
  #define CYTHON_COMPILING_IN_CPYTHON 0
  #define CYTHON_COMPILING_IN_LIMITED_API 0
  #define CYTHON_COMPILING_IN_GRAAL 0
  #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0
  #undef CYTHON_USE_TYPE_SLOTS
  #define CYTHON_USE_TYPE_SLOTS 1
  #ifndef CYTHON_USE_TYPE_SPECS
    #define CYTHON_USE_TYPE_SPECS 0
  #endif
  #undef CYTHON_USE_PYTYPE_LOOKUP
  #define CYTHON_USE_PYTYPE_LOOKUP 0
  #undef CYTHON_USE_PYLIST_INTERNALS
  #define CYTHON_USE_PYLIST_INTERNALS 0
  #undef CYTHON_USE_UNICODE_INTERNALS
  #define CYTHON_USE_UNICODE_INTERNALS 0
  #undef CYTHON_USE_UNICODE_WRITER
  #define CYTHON_USE_UNICODE_WRITER 0
  #undef CYTHON_USE_PYLONG_INTERNALS
  #define CYTHON_USE_PYLONG_INTERNALS 0
  #undef CYTHON_AVOID_BORROWED_REFS
  #define CYTHON_AVOID_BORROWED_REFS 1
  #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
  #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1
  #undef CYTHON_ASSUME_SAFE_MACROS
  #define CYTHON_ASSUME_SAFE_MACROS 0
  #ifndef CYTHON_ASSUME_SAFE_SIZE
    #define CYTHON_ASSUME_SAFE_SIZE 1
  #endif
  #undef CYTHON_UNPACK_METHODS
  #define CYTHON_UNPACK_METHODS 0
  #undef CYTHON_FAST_THREAD_STATE
  #define CYTHON_FAST_THREAD_STATE 0
  #undef CYTHON_FAST_GIL
  #define CYTHON_FAST_GIL 0
  #undef CYTHON_METH_FASTCALL
  #define CYTHON_METH_FASTCALL 0
  #undef CYTHON_FAST_PYCALL
  #define CYTHON_FAST_PYCALL 0
  #ifndef CYTHON_PEP487_INIT_SUBCLASS
    #define CYTHON_PEP487_INIT_SUBCLASS 1
  #endif
  #if PY_VERSION_HEX < 0x03090000
    #undef CYTHON_PEP489_MULTI_PHASE_INIT
    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
  #endif
  #undef CYTHON_USE_MODULE_STATE
  #define CYTHON_USE_MODULE_STATE 0
  #undef CYTHON_USE_SYS_MONITORING
  #define CYTHON_USE_SYS_MONITORING 0
  #ifndef CYTHON_USE_TP_FINALIZE
    #define CYTHON_USE_TP_FINALIZE (PYPY_VERSION_NUM >= 0x07030C00)
  #endif
  #undef CYTHON_USE_AM_SEND
  #define CYTHON_USE_AM_SEND 0
  #undef CYTHON_USE_DICT_VERSIONS
  #define CYTHON_USE_DICT_VERSIONS 0
  #undef CYTHON_USE_EXC_INFO_STACK
  #define CYTHON_USE_EXC_INFO_STACK 0
  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
    #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_NUM >= 0x07031100)
  #endif
  #undef CYTHON_USE_FREELISTS
  #define CYTHON_USE_FREELISTS 0
  #undef CYTHON_IMMORTAL_CONSTANTS
  #define CYTHON_IMMORTAL_CONSTANTS 0
#elif defined(CYTHON_LIMITED_API)
  #ifdef Py_LIMITED_API
    #undef __PYX_LIMITED_VERSION_HEX
    #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API
  #endif
  #define CYTHON_COMPILING_IN_PYPY 0
  #define CYTHON_COMPILING_IN_CPYTHON 0
  #define CYTHON_COMPILING_IN_LIMITED_API 1
  #define CYTHON_COMPILING_IN_GRAAL 0
  #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0
  #undef CYTHON_USE_TYPE_SLOTS
  #define CYTHON_USE_TYPE_SLOTS 0
  #undef CYTHON_USE_TYPE_SPECS
  #define CYTHON_USE_TYPE_SPECS 1
  #undef CYTHON_USE_PYTYPE_LOOKUP
  #define CYTHON_USE_PYTYPE_LOOKUP 0
  #undef CYTHON_USE_PYLIST_INTERNALS
  #define CYTHON_USE_PYLIST_INTERNALS 0
  #undef CYTHON_USE_UNICODE_INTERNALS
  #define CYTHON_USE_UNICODE_INTERNALS 0
  #ifndef CYTHON_USE_UNICODE_WRITER
    #define CYTHON_USE_UNICODE_WRITER 0
  #endif
  #undef CYTHON_USE_PYLONG_INTERNALS
  #define CYTHON_USE_PYLONG_INTERNALS 0
  #ifndef CYTHON_AVOID_BORROWED_REFS
    #define CYTHON_AVOID_BORROWED_REFS 0
  #endif
  #ifndef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
    #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0
  #endif
  #undef CYTHON_ASSUME_SAFE_MACROS
  #define CYTHON_ASSUME_SAFE_MACROS 0
  #undef CYTHON_ASSUME_SAFE_SIZE
  #define CYTHON_ASSUME_SAFE_SIZE 0
  #undef CYTHON_UNPACK_METHODS
  #define CYTHON_UNPACK_METHODS 0
  #undef CYTHON_FAST_THREAD_STATE
  #define CYTHON_FAST_THREAD_STATE 0
  #undef CYTHON_FAST_GIL
  #define CYTHON_FAST_GIL 0
  #undef CYTHON_METH_FASTCALL
  #define CYTHON_METH_FASTCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000)
  #undef CYTHON_FAST_PYCALL
  #define CYTHON_FAST_PYCALL 0
  #ifndef CYTHON_PEP487_INIT_SUBCLASS
    #define CYTHON_PEP487_INIT_SUBCLASS 1
  #endif
  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
  #endif
  #ifndef CYTHON_USE_MODULE_STATE
    #define CYTHON_USE_MODULE_STATE 0
  #endif
  #undef CYTHON_USE_SYS_MONITORING
  #define CYTHON_USE_SYS_MONITORING 0
  #ifndef CYTHON_USE_TP_FINALIZE
    #define CYTHON_USE_TP_FINALIZE 0
  #endif
  #ifndef CYTHON_USE_AM_SEND
    #define CYTHON_USE_AM_SEND (__PYX_LIMITED_VERSION_HEX >= 0x030A0000)
  #endif
  #undef CYTHON_USE_DICT_VERSIONS
  #define CYTHON_USE_DICT_VERSIONS 0
  #undef CYTHON_USE_EXC_INFO_STACK
  #define CYTHON_USE_EXC_INFO_STACK 0
  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
  #endif
  #ifndef CYTHON_USE_FREELISTS
  #define CYTHON_USE_FREELISTS 1
  #endif
  #undef CYTHON_IMMORTAL_CONSTANTS
  #define CYTHON_IMMORTAL_CONSTANTS 0
#else
  #define CYTHON_COMPILING_IN_PYPY 0
  #define CYTHON_COMPILING_IN_CPYTHON 1
  #define CYTHON_COMPILING_IN_LIMITED_API 0
  #define CYTHON_COMPILING_IN_GRAAL 0
  #ifdef Py_GIL_DISABLED
    #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 1
  #else
    #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0
  #endif
  #if PY_VERSION_HEX < 0x030A0000
    #undef CYTHON_USE_TYPE_SLOTS
    #define CYTHON_USE_TYPE_SLOTS 1
  #elif !defined(CYTHON_USE_TYPE_SLOTS)
    #define CYTHON_USE_TYPE_SLOTS 1
  #endif
  #ifndef CYTHON_USE_TYPE_SPECS
    #define CYTHON_USE_TYPE_SPECS 0
  #endif
  #ifndef CYTHON_USE_PYTYPE_LOOKUP
    #define CYTHON_USE_PYTYPE_LOOKUP 1
  #endif
  #ifndef CYTHON_USE_PYLONG_INTERNALS
    #define CYTHON_USE_PYLONG_INTERNALS 1
  #endif
  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
    #undef CYTHON_USE_PYLIST_INTERNALS
    #define CYTHON_USE_PYLIST_INTERNALS 0
  #elif !defined(CYTHON_USE_PYLIST_INTERNALS)
    #define CYTHON_USE_PYLIST_INTERNALS 1
  #endif
  #ifndef CYTHON_USE_UNICODE_INTERNALS
    #define CYTHON_USE_UNICODE_INTERNALS 1
  #endif
  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING || PY_VERSION_HEX >= 0x030B00A2
    #undef CYTHON_USE_UNICODE_WRITER
    #define CYTHON_USE_UNICODE_WRITER 0
  #elif !defined(CYTHON_USE_UNICODE_WRITER)
    #define CYTHON_USE_UNICODE_WRITER 1
  #endif
  #ifndef CYTHON_AVOID_BORROWED_REFS
    #define CYTHON_AVOID_BORROWED_REFS 0
  #endif
  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
    #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
    #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1
  #elif !defined(CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS)
    #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0
  #endif
  #ifndef CYTHON_ASSUME_SAFE_MACROS
    #define CYTHON_ASSUME_SAFE_MACROS 1
  #endif
  #ifndef CYTHON_ASSUME_SAFE_SIZE
    #define CYTHON_ASSUME_SAFE_SIZE 1
  #endif
  #ifndef CYTHON_UNPACK_METHODS
    #define CYTHON_UNPACK_METHODS 1
  #endif
  #ifndef CYTHON_FAST_THREAD_STATE
    #define CYTHON_FAST_THREAD_STATE 1
  #endif
  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
    #undef CYTHON_FAST_GIL
    #define CYTHON_FAST_GIL 0
  #elif !defined(CYTHON_FAST_GIL)
    #define CYTHON_FAST_GIL (PY_VERSION_HEX < 0x030C00A6)
  #endif
  #ifndef CYTHON_METH_FASTCALL
    #define CYTHON_METH_FASTCALL 1
  #endif
  #ifndef CYTHON_FAST_PYCALL
    #define CYTHON_FAST_PYCALL 1
  #endif
  #ifndef CYTHON_PEP487_INIT_SUBCLASS
    #define CYTHON_PEP487_INIT_SUBCLASS 1
  #endif
  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
  #endif
  #ifndef CYTHON_USE_MODULE_STATE
    #define CYTHON_USE_MODULE_STATE 0
  #endif
  #ifndef CYTHON_USE_SYS_MONITORING
    #define CYTHON_USE_SYS_MONITORING (PY_VERSION_HEX >= 0x030d00B1)
  #endif
  #ifndef CYTHON_USE_TP_FINALIZE
    #define CYTHON_USE_TP_FINALIZE 1
  #endif
  #ifndef CYTHON_USE_AM_SEND
    #define CYTHON_USE_AM_SEND 1
  #endif
  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
    #undef CYTHON_USE_DICT_VERSIONS
    #define CYTHON_USE_DICT_VERSIONS 0
  #elif !defined(CYTHON_USE_DICT_VERSIONS)
    #define CYTHON_USE_DICT_VERSIONS  (PY_VERSION_HEX < 0x030C00A5 && !CYTHON_USE_MODULE_STATE)
  #endif
  #ifndef CYTHON_USE_EXC_INFO_STACK
    #define CYTHON_USE_EXC_INFO_STACK 1
  #endif
  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
    #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
  #endif
  #ifndef CYTHON_USE_FREELISTS
    #define CYTHON_USE_FREELISTS (!CYTHON_COMPILING_IN_CPYTHON_FREETHREADING)
  #endif
  #if defined(CYTHON_IMMORTAL_CONSTANTS) && PY_VERSION_HEX < 0x030C0000
    #undef CYTHON_IMMORTAL_CONSTANTS
    #define CYTHON_IMMORTAL_CONSTANTS 0  // definitely won't work
  #elif !defined(CYTHON_IMMORTAL_CONSTANTS)
    #define CYTHON_IMMORTAL_CONSTANTS (PY_VERSION_HEX >= 0x030C0000 && !CYTHON_USE_MODULE_STATE && CYTHON_COMPILING_IN_CPYTHON_FREETHREADING)
  #endif
#endif
#ifndef CYTHON_COMPRESS_STRINGS
  #define CYTHON_COMPRESS_STRINGS 1
#endif
#ifndef CYTHON_FAST_PYCCALL
#define CYTHON_FAST_PYCCALL  CYTHON_FAST_PYCALL
#endif
#ifndef CYTHON_VECTORCALL
#if CYTHON_COMPILING_IN_LIMITED_API
#define CYTHON_VECTORCALL  (__PYX_LIMITED_VERSION_HEX >= 0x030C0000)
#else
#define CYTHON_VECTORCALL  (CYTHON_FAST_PYCCALL)
#endif
#endif
#if CYTHON_USE_PYLONG_INTERNALS
  #undef SHIFT
  #undef BASE
  #undef MASK
  #ifdef SIZEOF_VOID_P
    enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) };
  #endif
#endif
#ifndef __has_attribute
  #define __has_attribute(x) 0
#endif
#ifndef __has_cpp_attribute
  #define __has_cpp_attribute(x) 0
#endif
#ifndef CYTHON_RESTRICT
  #if defined(__GNUC__)
    #define CYTHON_RESTRICT __restrict__
  #elif defined(_MSC_VER) && _MSC_VER >= 1400
    #define CYTHON_RESTRICT __restrict
  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
    #define CYTHON_RESTRICT restrict
  #else
    #define CYTHON_RESTRICT
  #endif
#endif
#ifndef CYTHON_UNUSED
  #if defined(__cplusplus)
    /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17
     * but leads to warnings with -pedantic, since it is a C++17 feature */
    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
      #if __has_cpp_attribute(maybe_unused)
        #define CYTHON_UNUSED [[maybe_unused]]
      #endif
    #endif
  #endif
#endif
#ifndef CYTHON_UNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define CYTHON_UNUSED __attribute__ ((__unused__))
#   else
#     define CYTHON_UNUSED
#   endif
# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))
#   define CYTHON_UNUSED __attribute__ ((__unused__))
# else
#   define CYTHON_UNUSED
# endif
#endif
#ifndef CYTHON_UNUSED_VAR
#  if defined(__cplusplus)
     template<class T> void CYTHON_UNUSED_VAR( const T& ) { }
#  else
#    define CYTHON_UNUSED_VAR(x) (void)(x)
#  endif
#endif
#ifndef CYTHON_MAYBE_UNUSED_VAR
  #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x)
#endif
#ifndef CYTHON_NCP_UNUSED
# if CYTHON_COMPILING_IN_CPYTHON && !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
#  define CYTHON_NCP_UNUSED
# else
#  define CYTHON_NCP_UNUSED CYTHON_UNUSED
# endif
#endif
#ifndef CYTHON_USE_CPP_STD_MOVE
  #if defined(__cplusplus) && (\
    __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600))
    #define CYTHON_USE_CPP_STD_MOVE 1
  #else
    #define CYTHON_USE_CPP_STD_MOVE 0
  #endif
#endif
#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
#include <stdint.h>
typedef uintptr_t  __pyx_uintptr_t;
#ifndef CYTHON_FALLTHROUGH
  #if defined(__cplusplus)
    /* for clang __has_cpp_attribute(fallthrough) is true even before C++17
     * but leads to warnings with -pedantic, since it is a C++17 feature */
    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
      #if __has_cpp_attribute(fallthrough)
        #define CYTHON_FALLTHROUGH [[fallthrough]]
      #endif
    #endif
    #ifndef CYTHON_FALLTHROUGH
      #if __has_cpp_attribute(clang::fallthrough)
        #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
      #elif __has_cpp_attribute(gnu::fallthrough)
        #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
      #endif
    #endif
  #endif
  #ifndef CYTHON_FALLTHROUGH
    #if __has_attribute(fallthrough)
      #define CYTHON_FALLTHROUGH __attribute__((fallthrough))
    #else
      #define CYTHON_FALLTHROUGH
    #endif
  #endif
  #if defined(__clang__) && defined(__apple_build_version__)
    #if __apple_build_version__ < 7000000
      #undef  CYTHON_FALLTHROUGH
      #define CYTHON_FALLTHROUGH
    #endif
  #endif
#endif
#ifndef Py_UNREACHABLE
  #define Py_UNREACHABLE()  assert(0); abort()
#endif
#ifdef __cplusplus
  template <typename T>
  struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);};
  #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL<type>::value)
#else
  #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0)
#endif
#if CYTHON_COMPILING_IN_PYPY == 1
  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX < 0x030A0000)
#else
  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX < 0x03090000)
#endif
#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer))

/* CppInitCode */
#ifndef __cplusplus
  #error "Cython files generated with the C++ option must be compiled with a C++ compiler."
#endif
#ifndef CYTHON_INLINE
  #if defined(__clang__)
    #define CYTHON_INLINE __inline__ __attribute__ ((__unused__))
  #else
    #define CYTHON_INLINE inline
  #endif
#endif
template<typename T>
void __Pyx_call_destructor(T& x) {
    x.~T();
}
template<typename T>
class __Pyx_FakeReference {
  public:
    __Pyx_FakeReference() : ptr(NULL) { }
    __Pyx_FakeReference(const T& ref) : ptr(const_cast<T*>(&ref)) { }
    T *operator->() { return ptr; }
    T *operator&() { return ptr; }
    operator T&() { return *ptr; }
    template<typename U> bool operator ==(const U& other) const { return *ptr == other; }
    template<typename U> bool operator !=(const U& other) const { return *ptr != other; }
    template<typename U> bool operator==(const __Pyx_FakeReference<U>& other) const { return *ptr == *other.ptr; }
    template<typename U> bool operator!=(const __Pyx_FakeReference<U>& other) const { return *ptr != *other.ptr; }
  private:
    T *ptr;
};

/* PythonCompatibility */
#define __PYX_BUILD_PY_SSIZE_T "n"
#define CYTHON_FORMAT_SSIZE_T "z"
#define __Pyx_BUILTIN_MODULE_NAME "builtins"
#define __Pyx_DefaultClassType PyType_Type
#if CYTHON_COMPILING_IN_LIMITED_API
    #ifndef CO_OPTIMIZED
    static int CO_OPTIMIZED;
    #endif
    #ifndef CO_NEWLOCALS
    static int CO_NEWLOCALS;
    #endif
    #ifndef CO_VARARGS
    static int CO_VARARGS;
    #endif
    #ifndef CO_VARKEYWORDS
    static int CO_VARKEYWORDS;
    #endif
    #ifndef CO_ASYNC_GENERATOR
    static int CO_ASYNC_GENERATOR;
    #endif
    #ifndef CO_GENERATOR
    static int CO_GENERATOR;
    #endif
    #ifndef CO_COROUTINE
    static int CO_COROUTINE;
    #endif
#else
    #ifndef CO_COROUTINE
      #define CO_COROUTINE 0x80
    #endif
    #ifndef CO_ASYNC_GENERATOR
      #define CO_ASYNC_GENERATOR 0x200
    #endif
#endif
static int __Pyx_init_co_variables(void);
#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE)
  #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type)
#else
  #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type))
#endif
#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is)
  #define __Pyx_Py_Is(x, y)  Py_Is(x, y)
#else
  #define __Pyx_Py_Is(x, y) ((x) == (y))
#endif
#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone)
  #define __Pyx_Py_IsNone(ob) Py_IsNone(ob)
#else
  #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None)
#endif
#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue)
  #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob)
#else
  #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True)
#endif
#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse)
  #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob)
#else
  #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False)
#endif
#define __Pyx_NoneAsNull(obj)  (__Pyx_Py_IsNone(obj) ? NULL : (obj))
#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY
  #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o)
#else
  #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o)
#endif
#ifndef Py_TPFLAGS_CHECKTYPES
  #define Py_TPFLAGS_CHECKTYPES 0
#endif
#ifndef Py_TPFLAGS_HAVE_INDEX
  #define Py_TPFLAGS_HAVE_INDEX 0
#endif
#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
  #define Py_TPFLAGS_HAVE_NEWBUFFER 0
#endif
#ifndef Py_TPFLAGS_HAVE_FINALIZE
  #define Py_TPFLAGS_HAVE_FINALIZE 0
#endif
#ifndef Py_TPFLAGS_SEQUENCE
  #define Py_TPFLAGS_SEQUENCE 0
#endif
#ifndef Py_TPFLAGS_MAPPING
  #define Py_TPFLAGS_MAPPING 0
#endif
#ifndef Py_TPFLAGS_IMMUTABLETYPE
  #define Py_TPFLAGS_IMMUTABLETYPE (1UL << 8)
#endif
#ifndef Py_TPFLAGS_DISALLOW_INSTANTIATION
  #define Py_TPFLAGS_DISALLOW_INSTANTIATION (1UL << 7)
#endif
#ifndef METH_STACKLESS
  #define METH_STACKLESS 0
#endif
#ifndef METH_FASTCALL
  #ifndef METH_FASTCALL
     #define METH_FASTCALL 0x80
  #endif
  typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs);
  typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
                                                          Py_ssize_t nargs, PyObject *kwnames);
#else
  #if PY_VERSION_HEX >= 0x030d00A4
  #  define __Pyx_PyCFunctionFast PyCFunctionFast
  #  define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords
  #else
  #  define __Pyx_PyCFunctionFast _PyCFunctionFast
  #  define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
  #endif
#endif
#if CYTHON_METH_FASTCALL
  #define __Pyx_METH_FASTCALL METH_FASTCALL
  #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast
  #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords
#else
  #define __Pyx_METH_FASTCALL METH_VARARGS
  #define __Pyx_PyCFunction_FastCall PyCFunction
  #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords
#endif
#if CYTHON_VECTORCALL
  #define __pyx_vectorcallfunc vectorcallfunc
  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  PY_VECTORCALL_ARGUMENTS_OFFSET
  #define __Pyx_PyVectorcall_NARGS(n)  PyVectorcall_NARGS((size_t)(n))
#else
  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  0
  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(n))
#endif
#if PY_VERSION_HEX >= 0x030900B1
#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_CheckExact(func)
#else
#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_Check(func)
#endif
#define __Pyx_CyOrPyCFunction_Check(func)  PyCFunction_Check(func)
#if CYTHON_COMPILING_IN_CPYTHON
#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  (((PyCFunctionObject*)(func))->m_ml->ml_meth)
#elif !CYTHON_COMPILING_IN_LIMITED_API
#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  PyCFunction_GET_FUNCTION(func)
#endif
#if CYTHON_COMPILING_IN_CPYTHON
#define __Pyx_CyOrPyCFunction_GET_FLAGS(func)  (((PyCFunctionObject*)(func))->m_ml->ml_flags)
static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) {
    return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self;
}
#endif
static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void (*cfunc)(void)) {
#if CYTHON_COMPILING_IN_LIMITED_API
    return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
#else
    return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
#endif
}
#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCFunction(func, cfunc)
#if PY_VERSION_HEX < 0x03090000 || (CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000)
  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  ((void)m, PyType_FromSpecWithBases(s, b))
  typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *);
#else
  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  PyType_FromModuleAndSpec(m, s, b)
  #define __Pyx_PyCMethod  PyCMethod
#endif
#ifndef METH_METHOD
  #define METH_METHOD 0x200
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
  #define PyObject_Malloc(s)   PyMem_Malloc(s)
  #define PyObject_Free(p)     PyMem_Free(p)
  #define PyObject_Realloc(p)  PyMem_Realloc(p)
#endif
#if CYTHON_COMPILING_IN_LIMITED_API
  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)
#elif CYTHON_COMPILING_IN_GRAAL && defined(GRAALPY_VERSION_NUM) && GRAALPY_VERSION_NUM > 0x19000000
  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) GraalPyFrame_SetLineNumber((frame), (lineno))
#elif CYTHON_COMPILING_IN_GRAAL
  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) _PyFrame_SetLineNumber((frame), (lineno))
#else
  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
#endif
#if CYTHON_COMPILING_IN_LIMITED_API
  #define __Pyx_PyThreadState_Current PyThreadState_Get()
#elif !CYTHON_FAST_THREAD_STATE
  #define __Pyx_PyThreadState_Current PyThreadState_GET()
#elif PY_VERSION_HEX >= 0x030d00A1
  #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked()
#else
  #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
#endif
#if CYTHON_USE_MODULE_STATE
static CYTHON_INLINE void *__Pyx__PyModule_GetState(PyObject *op)
{
    void *result;
    result = PyModule_GetState(op);
    if (!result)
        Py_FatalError("Couldn't find the module state");
    return result;
}
#define __Pyx_PyModule_GetState(o) (__pyx_mstatetype *)__Pyx__PyModule_GetState(o)
#else
#define __Pyx_PyModule_GetState(op) ((void)op,__pyx_mstate_global)
#endif
#define __Pyx_PyObject_GetSlot(obj, name, func_ctype)  __Pyx_PyType_GetSlot(Py_TYPE((PyObject *) obj), name, func_ctype)
#define __Pyx_PyObject_TryGetSlot(obj, name, func_ctype) __Pyx_PyType_TryGetSlot(Py_TYPE(obj), name, func_ctype)
#define __Pyx_PyObject_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(Py_TYPE(obj), sub, name, func_ctype)
#define __Pyx_PyObject_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSubSlot(Py_TYPE(obj), sub, name, func_ctype)
#if CYTHON_USE_TYPE_SLOTS
  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((type)->name)
  #define __Pyx_PyType_TryGetSlot(type, name, func_ctype) __Pyx_PyType_GetSlot(type, name, func_ctype)
  #define __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) (((type)->sub) ? ((type)->sub->name) : NULL)
  #define __Pyx_PyType_TryGetSubSlot(type, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype)
#else
  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((func_ctype) PyType_GetSlot((type), Py_##name))
  #define __Pyx_PyType_TryGetSlot(type, name, func_ctype)\
    ((__PYX_LIMITED_VERSION_HEX >= 0x030A0000 ||\
     (PyType_GetFlags(type) & Py_TPFLAGS_HEAPTYPE) || __Pyx_get_runtime_version() >= 0x030A0000) ?\
     __Pyx_PyType_GetSlot(type, name, func_ctype) : NULL)
  #define __Pyx_PyType_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSlot(obj, name, func_ctype)
  #define __Pyx_PyType_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSlot(obj, name, func_ctype)
#endif
#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
#define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
#else
#define __Pyx_PyDict_NewPresized(n)  PyDict_New()
#endif
#define __Pyx_PyNumber_Divide(x,y)         PyNumber_TrueDivide(x,y)
#define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceTrueDivide(x,y)
#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_UNICODE_INTERNALS
#define __Pyx_PyDict_GetItemStrWithError(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) {
    PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name);
    if (res == NULL) PyErr_Clear();
    return res;
}
#elif !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000
#define __Pyx_PyDict_GetItemStrWithError  PyDict_GetItemWithError
#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
#else
static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) {
#if CYTHON_COMPILING_IN_PYPY
    return PyDict_GetItem(dict, name);
#else
    PyDictEntry *ep;
    PyDictObject *mp = (PyDictObject*) dict;
    long hash = ((PyStringObject *) name)->ob_shash;
    assert(hash != -1);
    ep = (mp->ma_lookup)(mp, name, hash);
    if (ep == NULL) {
        return NULL;
    }
    return ep->me_value;
#endif
}
#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
#endif
#if CYTHON_USE_TYPE_SLOTS
  #define __Pyx_PyType_GetFlags(tp)   (((PyTypeObject *)tp)->tp_flags)
  #define __Pyx_PyType_HasFeature(type, feature)  ((__Pyx_PyType_GetFlags(type) & (feature)) != 0)
#else
  #define __Pyx_PyType_GetFlags(tp)   (PyType_GetFlags((PyTypeObject *)tp))
  #define __Pyx_PyType_HasFeature(type, feature)  PyType_HasFeature(type, feature)
#endif
#define __Pyx_PyObject_GetIterNextFunc(iterator)  __Pyx_PyObject_GetSlot(iterator, tp_iternext, iternextfunc)
#if CYTHON_USE_TYPE_SPECS
#define __Pyx_PyHeapTypeObject_GC_Del(obj)  {\
    PyTypeObject *type = Py_TYPE((PyObject*)obj);\
    assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\
    PyObject_GC_Del(obj);\
    Py_DECREF(type);\
}
#else
#define __Pyx_PyHeapTypeObject_GC_Del(obj)  PyObject_GC_Del(obj)
#endif
#if CYTHON_COMPILING_IN_LIMITED_API
  #define __Pyx_PyUnicode_READY(op)       (0)
  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i)
  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((void)u, 1114111U)
  #define __Pyx_PyUnicode_KIND(u)         ((void)u, (0))
  #define __Pyx_PyUnicode_DATA(u)         ((void*)u)
  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)k, PyUnicode_ReadChar((PyObject*)(d), i))
  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GetLength(u))
#else
  #if PY_VERSION_HEX >= 0x030C0000
    #define __Pyx_PyUnicode_READY(op)       (0)
  #else
    #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
                                                0 : _PyUnicode_Ready((PyObject *)(op)))
  #endif
  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
  #define __Pyx_PyUnicode_KIND(u)         ((int)PyUnicode_KIND(u))
  #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
  #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, (Py_UCS4) ch)
  #if PY_VERSION_HEX >= 0x030C0000
    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
  #else
    #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
    #else
    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
    #endif
  #endif
#endif
#if CYTHON_COMPILING_IN_PYPY
  #define __Pyx_PyUnicode_Concat(a, b)      PyNumber_Add(a, b)
  #define __Pyx_PyUnicode_ConcatSafe(a, b)  PyNumber_Add(a, b)
#else
  #define __Pyx_PyUnicode_Concat(a, b)      PyUnicode_Concat(a, b)
  #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
      PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
#endif
#if CYTHON_COMPILING_IN_PYPY
  #if !defined(PyUnicode_DecodeUnicodeEscape)
    #define PyUnicode_DecodeUnicodeEscape(s, size, errors)  PyUnicode_Decode(s, size, "unicode_escape", errors)
  #endif
  #if !defined(PyUnicode_Contains)
    #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
  #endif
  #if !defined(PyByteArray_Check)
    #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
  #endif
  #if !defined(PyObject_Format)
    #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
  #endif
#endif
#define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  #define __Pyx_PySequence_ListKeepNew(obj)\
    (likely(PyList_CheckExact(obj) && PyUnstable_Object_IsUniquelyReferenced(obj)) ? __Pyx_NewRef(obj) : PySequence_List(obj))
#elif CYTHON_COMPILING_IN_CPYTHON
  #define __Pyx_PySequence_ListKeepNew(obj)\
    (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj))
#else
  #define __Pyx_PySequence_ListKeepNew(obj)  PySequence_List(obj)
#endif
#ifndef PySet_CheckExact
  #define PySet_CheckExact(obj)        __Pyx_IS_TYPE(obj, &PySet_Type)
#endif
#if PY_VERSION_HEX >= 0x030900A4
  #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
  #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size)
#else
  #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt)
  #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
#endif
enum __Pyx_ReferenceSharing {
  __Pyx_ReferenceSharing_DefinitelyUnique, // We created it so we know it's unshared - no need to check
  __Pyx_ReferenceSharing_OwnStrongReference,
  __Pyx_ReferenceSharing_FunctionArgument,
  __Pyx_ReferenceSharing_SharedReference, // Never trust it to be unshared because it's a global or similar
};
#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && PY_VERSION_HEX >= 0x030E0000
#define __Pyx_IS_UNIQUELY_REFERENCED(o, sharing)\
    (sharing == __Pyx_ReferenceSharing_DefinitelyUnique ? 1 :\
      (sharing == __Pyx_ReferenceSharing_FunctionArgument ? PyUnstable_Object_IsUniqueReferencedTemporary(o) :\
      (sharing == __Pyx_ReferenceSharing_OwnStrongReference ? PyUnstable_Object_IsUniquelyReferenced(o) : 0)))
#elif (CYTHON_COMPILING_IN_CPYTHON && !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) || CYTHON_COMPILING_IN_LIMITED_API
#define __Pyx_IS_UNIQUELY_REFERENCED(o, sharing) (((void)sharing), Py_REFCNT(o) == 1)
#else
#define __Pyx_IS_UNIQUELY_REFERENCED(o, sharing) (((void)o), ((void)sharing), 0)
#endif
#if CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
  #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
    #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i)
  #elif CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS
    #define __Pyx_PyList_GetItemRef(o, i) (likely((i) >= 0) ? PySequence_GetItem(o, i) : (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL))
  #else
    #define __Pyx_PyList_GetItemRef(o, i) PySequence_ITEM(o, i)
  #endif
#elif CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS
  #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
    #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i)
  #else
    #define __Pyx_PyList_GetItemRef(o, i) __Pyx_XNewRef(PyList_GetItem(o, i))
  #endif
#else
  #define __Pyx_PyList_GetItemRef(o, i) __Pyx_NewRef(PyList_GET_ITEM(o, i))
#endif
#if CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS && !CYTHON_COMPILING_IN_LIMITED_API && CYTHON_ASSUME_SAFE_MACROS
  #define __Pyx_PyList_GetItemRefFast(o, i, unsafe_shared) (__Pyx_IS_UNIQUELY_REFERENCED(o, unsafe_shared) ?\
    __Pyx_NewRef(PyList_GET_ITEM(o, i)) : __Pyx_PyList_GetItemRef(o, i))
#else
  #define __Pyx_PyList_GetItemRefFast(o, i, unsafe_shared) __Pyx_PyList_GetItemRef(o, i)
#endif
#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
#define __Pyx_PyDict_GetItemRef(dict, key, result) PyDict_GetItemRef(dict, key, result)
#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) {
  *result = PyObject_GetItem(dict, key);
  if (*result == NULL) {
    if (PyErr_ExceptionMatches(PyExc_KeyError)) {
      PyErr_Clear();
      return 0;
    }
    return -1;
  }
  return 1;
}
#else
static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) {
  *result = PyDict_GetItemWithError(dict, key);
  if (*result == NULL) {
    return PyErr_Occurred() ? -1 : 0;
  }
  Py_INCREF(*result);
  return 1;
}
#endif
#if defined(CYTHON_DEBUG_VISIT_CONST) && CYTHON_DEBUG_VISIT_CONST
  #define __Pyx_VISIT_CONST(obj)  Py_VISIT(obj)
#else
  #define __Pyx_VISIT_CONST(obj)
#endif
#if CYTHON_ASSUME_SAFE_MACROS
  #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i)
  #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
  #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0))
  #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GET_ITEM(o, i)
  #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0))
  #define __Pyx_PyList_GET_ITEM(o, i) PyList_GET_ITEM(o, i)
#else
  #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i)
  #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
  #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v)
  #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GetItem(o, i)
  #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v)
  #define __Pyx_PyList_GET_ITEM(o, i) PyList_GetItem(o, i)
#endif
#if CYTHON_ASSUME_SAFE_SIZE
  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o)
  #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o)
  #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o)
  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o)
  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o)
  #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GET_LENGTH(o)
#else
  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o)
  #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o)
  #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o)
  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o)
  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o)
  #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GetLength(o)
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_InternFromString)
  #define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
#endif
#define __Pyx_PyLong_FromHash_t PyLong_FromSsize_t
#define __Pyx_PyLong_AsHash_t   __Pyx_PyIndex_AsSsize_t
#if __PYX_LIMITED_VERSION_HEX >= 0x030A0000
    #define __Pyx_PySendResult PySendResult
#else
    typedef enum {
        PYGEN_RETURN = 0,
        PYGEN_ERROR = -1,
        PYGEN_NEXT = 1,
    } __Pyx_PySendResult;
#endif
#if CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX < 0x030A00A3
  typedef __Pyx_PySendResult (*__Pyx_pyiter_sendfunc)(PyObject *iter, PyObject *value, PyObject **result);
#else
  #define __Pyx_pyiter_sendfunc sendfunc
#endif
#if !CYTHON_USE_AM_SEND
#define __PYX_HAS_PY_AM_SEND 0
#elif __PYX_LIMITED_VERSION_HEX >= 0x030A0000
#define __PYX_HAS_PY_AM_SEND 1
#else
#define __PYX_HAS_PY_AM_SEND 2  // our own backported implementation
#endif
#if __PYX_HAS_PY_AM_SEND < 2
    #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
#else
    typedef struct {
        unaryfunc am_await;
        unaryfunc am_aiter;
        unaryfunc am_anext;
        __Pyx_pyiter_sendfunc am_send;
    } __Pyx_PyAsyncMethodsStruct;
    #define __Pyx_SlotTpAsAsync(s) ((PyAsyncMethods*)(s))
#endif
#if CYTHON_USE_AM_SEND && PY_VERSION_HEX < 0x030A00F0
    #define __Pyx_TPFLAGS_HAVE_AM_SEND (1UL << 21)
#else
    #define __Pyx_TPFLAGS_HAVE_AM_SEND (0)
#endif
#if PY_VERSION_HEX >= 0x03090000
#define __Pyx_PyInterpreterState_Get() PyInterpreterState_Get()
#else
#define __Pyx_PyInterpreterState_Get() PyThreadState_Get()->interp
#endif
#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030A0000
#ifdef __cplusplus
extern "C"
#endif
PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize);
#endif
#if CYTHON_COMPILING_IN_LIMITED_API
static int __Pyx_init_co_variable(PyObject *inspect, const char* name, int *write_to) {
    int value;
    PyObject *py_value = PyObject_GetAttrString(inspect, name);
    if (!py_value) return 0;
    value = (int) PyLong_AsLong(py_value);
    Py_DECREF(py_value);
    *write_to = value;
    return value != -1 || !PyErr_Occurred();
}
static int __Pyx_init_co_variables(void) {
    PyObject *inspect;
    int result;
    inspect = PyImport_ImportModule("inspect");
    result =
#if !defined(CO_OPTIMIZED)
        __Pyx_init_co_variable(inspect, "CO_OPTIMIZED", &CO_OPTIMIZED) &&
#endif
#if !defined(CO_NEWLOCALS)
        __Pyx_init_co_variable(inspect, "CO_NEWLOCALS", &CO_NEWLOCALS) &&
#endif
#if !defined(CO_VARARGS)
        __Pyx_init_co_variable(inspect, "CO_VARARGS", &CO_VARARGS) &&
#endif
#if !defined(CO_VARKEYWORDS)
        __Pyx_init_co_variable(inspect, "CO_VARKEYWORDS", &CO_VARKEYWORDS) &&
#endif
#if !defined(CO_ASYNC_GENERATOR)
        __Pyx_init_co_variable(inspect, "CO_ASYNC_GENERATOR", &CO_ASYNC_GENERATOR) &&
#endif
#if !defined(CO_GENERATOR)
        __Pyx_init_co_variable(inspect, "CO_GENERATOR", &CO_GENERATOR) &&
#endif
#if !defined(CO_COROUTINE)
        __Pyx_init_co_variable(inspect, "CO_COROUTINE", &CO_COROUTINE) &&
#endif
        1;
    Py_DECREF(inspect);
    return result ? 0 : -1;
}
#else
static int __Pyx_init_co_variables(void) {
    return 0;  // It's a limited API-only feature
}
#endif

/* MathInitCode */
#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS)
  #ifndef _USE_MATH_DEFINES
    #define _USE_MATH_DEFINES
  #endif
#endif
#include <math.h>
#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL)
#define __Pyx_truncl trunc
#else
#define __Pyx_truncl truncl
#endif

#ifndef CYTHON_CLINE_IN_TRACEBACK_RUNTIME
#define CYTHON_CLINE_IN_TRACEBACK_RUNTIME 0
#endif
#ifndef CYTHON_CLINE_IN_TRACEBACK
#define CYTHON_CLINE_IN_TRACEBACK CYTHON_CLINE_IN_TRACEBACK_RUNTIME
#endif
#if CYTHON_CLINE_IN_TRACEBACK
#define __PYX_MARK_ERR_POS(f_index, lineno)  { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; __pyx_clineno = __LINE__; (void) __pyx_clineno; }
#else
#define __PYX_MARK_ERR_POS(f_index, lineno)  { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; (void) __pyx_clineno; }
#endif
#define __PYX_ERR(f_index, lineno, Ln_error) \
    { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }

#ifdef CYTHON_EXTERN_C
    #undef __PYX_EXTERN_C
    #define __PYX_EXTERN_C CYTHON_EXTERN_C
#elif defined(__PYX_EXTERN_C)
    #ifdef _MSC_VER
    #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.")
    #else
    #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.
    #endif
#else
    #define __PYX_EXTERN_C extern "C++"
#endif

#define __PYX_HAVE__cuda__bindings___internal___nvml
#define __PYX_HAVE_API__cuda__bindings___internal___nvml
/* Early includes */
#include <stdint.h>
#include <dlfcn.h>
#ifdef _OPENMP
#include <omp.h>
#endif /* _OPENMP */

#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS)
#define CYTHON_WITHOUT_ASSERTIONS
#endif

#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0
#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0
#define __PYX_DEFAULT_STRING_ENCODING ""
#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString
#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
#define __Pyx_uchar_cast(c) ((unsigned char)c)
#define __Pyx_long_cast(x) ((long)x)
#define __Pyx_fits_Py_ssize_t(v, type, is_signed)  (\
    (sizeof(type) < sizeof(Py_ssize_t))  ||\
    (sizeof(type) > sizeof(Py_ssize_t) &&\
          likely(v < (type)PY_SSIZE_T_MAX ||\
                 v == (type)PY_SSIZE_T_MAX)  &&\
          (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\
                                v == (type)PY_SSIZE_T_MIN)))  ||\
    (sizeof(type) == sizeof(Py_ssize_t) &&\
          (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\
                               v == (type)PY_SSIZE_T_MAX)))  )
static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
    return (size_t) i < (size_t) limit;
}
#if defined (__cplusplus) && __cplusplus >= 201103L
    #include <cstdlib>
    #define __Pyx_sst_abs(value) std::abs(value)
#elif SIZEOF_INT >= SIZEOF_SIZE_T
    #define __Pyx_sst_abs(value) abs(value)
#elif SIZEOF_LONG >= SIZEOF_SIZE_T
    #define __Pyx_sst_abs(value) labs(value)
#elif defined (_MSC_VER)
    #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value))
#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
    #define __Pyx_sst_abs(value) llabs(value)
#elif defined (__GNUC__)
    #define __Pyx_sst_abs(value) __builtin_llabs(value)
#else
    #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
#endif
static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s);
static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*);
#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
#define __Pyx_PyBytes_FromString        PyBytes_FromString
#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
#if CYTHON_ASSUME_SAFE_MACROS
    #define __Pyx_PyBytes_AsWritableString(s)     ((char*) PyBytes_AS_STRING(s))
    #define __Pyx_PyBytes_AsWritableSString(s)    ((signed char*) PyBytes_AS_STRING(s))
    #define __Pyx_PyBytes_AsWritableUString(s)    ((unsigned char*) PyBytes_AS_STRING(s))
    #define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AS_STRING(s))
    #define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AS_STRING(s))
    #define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AS_STRING(s))
    #define __Pyx_PyByteArray_AsString(s) PyByteArray_AS_STRING(s)
#else
    #define __Pyx_PyBytes_AsWritableString(s)     ((char*) PyBytes_AsString(s))
    #define __Pyx_PyBytes_AsWritableSString(s)    ((signed char*) PyBytes_AsString(s))
    #define __Pyx_PyBytes_AsWritableUString(s)    ((unsigned char*) PyBytes_AsString(s))
    #define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AsString(s))
    #define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AsString(s))
    #define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AsString(s))
    #define __Pyx_PyByteArray_AsString(s) PyByteArray_AsString(s)
#endif
#define __Pyx_PyObject_AsWritableString(s)    ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_AsSString(s)    ((const signed char*) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_AsUString(s)    ((const unsigned char*) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
#define __Pyx_PyBytes_FromCString(s)   __Pyx_PyBytes_FromString((const char*)s)
#define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
#define __Pyx_PyUnicode_FromOrdinal(o)       PyUnicode_FromOrdinal((int)o)
#define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
static CYTHON_INLINE PyObject *__Pyx_NewRef(PyObject *obj) {
#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_NewRef)
    return Py_NewRef(obj);
#else
    Py_INCREF(obj);
    return obj;
#endif
}
static CYTHON_INLINE PyObject *__Pyx_XNewRef(PyObject *obj) {
#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_XNewRef)
    return Py_XNewRef(obj);
#else
    Py_XINCREF(obj);
    return obj;
#endif
}
static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b);
static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b);
static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*);
static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(PyObject* x);
#define __Pyx_PySequence_Tuple(obj)\
    (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj))
static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t);
static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);
#if CYTHON_ASSUME_SAFE_MACROS
#define __Pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AS_DOUBLE(x)
#else
#define __Pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AsDouble(x)
#endif
#define __Pyx_PyFloat_AsFloat(x) ((float) __Pyx_PyFloat_AsDouble(x))
#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))
#if CYTHON_USE_PYLONG_INTERNALS
  #if PY_VERSION_HEX >= 0x030C00A7
  #ifndef _PyLong_SIGN_MASK
    #define _PyLong_SIGN_MASK 3
  #endif
  #ifndef _PyLong_NON_SIZE_BITS
    #define _PyLong_NON_SIZE_BITS 3
  #endif
  #define __Pyx_PyLong_Sign(x)  (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)
  #define __Pyx_PyLong_IsNeg(x)  ((__Pyx_PyLong_Sign(x) & 2) != 0)
  #define __Pyx_PyLong_IsNonNeg(x)  (!__Pyx_PyLong_IsNeg(x))
  #define __Pyx_PyLong_IsZero(x)  (__Pyx_PyLong_Sign(x) & 1)
  #define __Pyx_PyLong_IsPos(x)  (__Pyx_PyLong_Sign(x) == 0)
  #define __Pyx_PyLong_CompactValueUnsigned(x)  (__Pyx_PyLong_Digits(x)[0])
  #define __Pyx_PyLong_DigitCount(x)  ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS))
  #define __Pyx_PyLong_SignedDigitCount(x)\
        ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x))
  #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue)
    #define __Pyx_PyLong_IsCompact(x)     PyUnstable_Long_IsCompact((PyLongObject*) x)
    #define __Pyx_PyLong_CompactValue(x)  PyUnstable_Long_CompactValue((PyLongObject*) x)
  #else
    #define __Pyx_PyLong_IsCompact(x)     (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS))
    #define __Pyx_PyLong_CompactValue(x)  ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0])
  #endif
  typedef Py_ssize_t  __Pyx_compact_pylong;
  typedef size_t  __Pyx_compact_upylong;
  #else
  #define __Pyx_PyLong_IsNeg(x)  (Py_SIZE(x) < 0)
  #define __Pyx_PyLong_IsNonNeg(x)  (Py_SIZE(x) >= 0)
  #define __Pyx_PyLong_IsZero(x)  (Py_SIZE(x) == 0)
  #define __Pyx_PyLong_IsPos(x)  (Py_SIZE(x) > 0)
  #define __Pyx_PyLong_CompactValueUnsigned(x)  ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0])
  #define __Pyx_PyLong_DigitCount(x)  __Pyx_sst_abs(Py_SIZE(x))
  #define __Pyx_PyLong_SignedDigitCount(x)  Py_SIZE(x)
  #define __Pyx_PyLong_IsCompact(x)  (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1)
  #define __Pyx_PyLong_CompactValue(x)\
        ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0]))
  typedef sdigit  __Pyx_compact_pylong;
  typedef digit  __Pyx_compact_upylong;
  #endif
  #if PY_VERSION_HEX >= 0x030C00A5
  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->long_value.ob_digit)
  #else
  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->ob_digit)
  #endif
#endif
#if __PYX_DEFAULT_STRING_ENCODING_IS_UTF8
  #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
#elif __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
  #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeASCII(c_str, size, NULL)
#else
  #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
#endif


/* Test for GCC > 2.95 */
#if defined(__GNUC__)     && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
  #define likely(x)   __builtin_expect(!!(x), 1)
  #define unlikely(x) __builtin_expect(!!(x), 0)
#else /* !__GNUC__ or GCC < 2.95 */
  #define likely(x)   (x)
  #define unlikely(x) (x)
#endif /* __GNUC__ */
/* PretendToInitialize */
#ifdef __cplusplus
#if __cplusplus > 201103L
#include <type_traits>
#endif
template <typename T>
static void __Pyx_pretend_to_initialize(T* ptr) {
#if __cplusplus > 201103L
    if ((std::is_trivially_default_constructible<T>::value))
#endif
        *ptr = T();
    (void)ptr;
}
#else
static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
#endif


#if !CYTHON_USE_MODULE_STATE
static PyObject *__pyx_m = NULL;
#endif
static int __pyx_lineno;
static int __pyx_clineno = 0;
static const char * const __pyx_cfilenm = __FILE__;
static const char *__pyx_filename;

/* #### Code section: filename_table ### */

static const char* const __pyx_f[] = {
  "cuda/bindings/_internal/_nvml.pyx",
};
/* #### Code section: utility_code_proto_before_types ### */
/* ForceInitThreads.proto */
#ifndef __PYX_FORCE_INIT_THREADS
  #define __PYX_FORCE_INIT_THREADS 0
#endif

/* NoFastGil.proto */
#define __Pyx_PyGILState_Ensure PyGILState_Ensure
#define __Pyx_PyGILState_Release PyGILState_Release
#define __Pyx_FastGIL_Remember()
#define __Pyx_FastGIL_Forget()
#define __Pyx_FastGilFuncInit()

/* Atomics.proto (used by UnpackUnboundCMethod) */
#include <pythread.h>
#ifndef CYTHON_ATOMICS
    #define CYTHON_ATOMICS 1
#endif
#define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS
#define __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
#define __pyx_atomic_int_type int
#define __pyx_nonatomic_int_type int
#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\
                        (__STDC_VERSION__ >= 201112L) &&\
                        !defined(__STDC_NO_ATOMICS__))
    #include <stdatomic.h>
#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\
                    (__cplusplus >= 201103L) ||\
                    (defined(_MSC_VER) && _MSC_VER >= 1700)))
    #include <atomic>
#endif
#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\
                        (__STDC_VERSION__ >= 201112L) &&\
                        !defined(__STDC_NO_ATOMICS__) &&\
                       ATOMIC_INT_LOCK_FREE == 2)
    #undef __pyx_atomic_int_type
    #define __pyx_atomic_int_type atomic_int
    #define __pyx_atomic_ptr_type atomic_uintptr_t
    #define __pyx_nonatomic_ptr_type uintptr_t
    #define __pyx_atomic_incr_relaxed(value) atomic_fetch_add_explicit(value, 1, memory_order_relaxed)
    #define __pyx_atomic_incr_acq_rel(value) atomic_fetch_add_explicit(value, 1, memory_order_acq_rel)
    #define __pyx_atomic_decr_acq_rel(value) atomic_fetch_sub_explicit(value, 1, memory_order_acq_rel)
    #define __pyx_atomic_sub(value, arg) atomic_fetch_sub(value, arg)
    #define __pyx_atomic_int_cmp_exchange(value, expected, desired) atomic_compare_exchange_strong(value, expected, desired)
    #define __pyx_atomic_load(value) atomic_load(value)
    #define __pyx_atomic_store(value, new_value) atomic_store(value, new_value)
    #define __pyx_atomic_pointer_load_relaxed(value) atomic_load_explicit(value, memory_order_relaxed)
    #define __pyx_atomic_pointer_load_acquire(value) atomic_load_explicit(value, memory_order_acquire)
    #define __pyx_atomic_pointer_exchange(value, new_value) atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value)
    #define __pyx_atomic_pointer_cmp_exchange(value, expected, desired) atomic_compare_exchange_strong(value, expected, desired)
    #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER)
        #pragma message ("Using standard C atomics")
    #elif defined(__PYX_DEBUG_ATOMICS)
        #warning "Using standard C atomics"
    #endif
#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\
                    (__cplusplus >= 201103L) ||\
\
                    (defined(_MSC_VER) && _MSC_VER >= 1700)) &&\
                    ATOMIC_INT_LOCK_FREE == 2)
    #undef __pyx_atomic_int_type
    #define __pyx_atomic_int_type std::atomic_int
    #define __pyx_atomic_ptr_type std::atomic_uintptr_t
    #define __pyx_nonatomic_ptr_type uintptr_t
    #define __pyx_atomic_incr_relaxed(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_relaxed)
    #define __pyx_atomic_incr_acq_rel(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_acq_rel)
    #define __pyx_atomic_decr_acq_rel(value) std::atomic_fetch_sub_explicit(value, 1, std::memory_order_acq_rel)
    #define __pyx_atomic_sub(value, arg) std::atomic_fetch_sub(value, arg)
    #define __pyx_atomic_int_cmp_exchange(value, expected, desired) std::atomic_compare_exchange_strong(value, expected, desired)
    #define __pyx_atomic_load(value) std::atomic_load(value)
    #define __pyx_atomic_store(value, new_value) std::atomic_store(value, new_value)
    #define __pyx_atomic_pointer_load_relaxed(value) std::atomic_load_explicit(value, std::memory_order_relaxed)
    #define __pyx_atomic_pointer_load_acquire(value) std::atomic_load_explicit(value, std::memory_order_acquire)
    #define __pyx_atomic_pointer_exchange(value, new_value) std::atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value)
    #define __pyx_atomic_pointer_cmp_exchange(value, expected, desired) std::atomic_compare_exchange_strong(value, expected, desired)
    #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER)
        #pragma message ("Using standard C++ atomics")
    #elif defined(__PYX_DEBUG_ATOMICS)
        #warning "Using standard C++ atomics"
    #endif
#elif CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\
                    (__GNUC_MINOR__ > 1 ||\
                    (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2))))
    #define __pyx_atomic_ptr_type void*
    #define __pyx_nonatomic_ptr_type void*
    #define __pyx_atomic_incr_relaxed(value) __sync_fetch_and_add(value, 1)
    #define __pyx_atomic_incr_acq_rel(value) __sync_fetch_and_add(value, 1)
    #define __pyx_atomic_decr_acq_rel(value) __sync_fetch_and_sub(value, 1)
    #define __pyx_atomic_sub(value, arg) __sync_fetch_and_sub(value, arg)
    static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) {
        __pyx_nonatomic_int_type old = __sync_val_compare_and_swap(value, *expected, desired);
        int result = old == *expected;
        *expected = old;
        return result;
    }
    #define __pyx_atomic_load(value) __sync_fetch_and_add(value, 0)
    #define __pyx_atomic_store(value, new_value) __sync_lock_test_and_set(value, new_value)
    #define __pyx_atomic_pointer_load_relaxed(value) __sync_fetch_and_add(value, 0)
    #define __pyx_atomic_pointer_load_acquire(value) __sync_fetch_and_add(value, 0)
    #define __pyx_atomic_pointer_exchange(value, new_value) __sync_lock_test_and_set(value, (__pyx_atomic_ptr_type)new_value)
    static CYTHON_INLINE int __pyx_atomic_pointer_cmp_exchange(__pyx_atomic_ptr_type* value, __pyx_nonatomic_ptr_type* expected, __pyx_nonatomic_ptr_type desired) {
        __pyx_nonatomic_ptr_type old = __sync_val_compare_and_swap(value, *expected, desired);
        int result = old == *expected;
        *expected = old;
        return result;
    }
    #ifdef __PYX_DEBUG_ATOMICS
        #warning "Using GNU atomics"
    #endif
#elif CYTHON_ATOMICS && defined(_MSC_VER)
    #include <intrin.h>
    #undef __pyx_atomic_int_type
    #define __pyx_atomic_int_type long
    #define __pyx_atomic_ptr_type void*
    #undef __pyx_nonatomic_int_type
    #define __pyx_nonatomic_int_type long
    #define __pyx_nonatomic_ptr_type void*
    #pragma intrinsic (_InterlockedExchangeAdd, _InterlockedExchange, _InterlockedCompareExchange, _InterlockedCompareExchangePointer, _InterlockedExchangePointer)
    #define __pyx_atomic_incr_relaxed(value) _InterlockedExchangeAdd(value, 1)
    #define __pyx_atomic_incr_acq_rel(value) _InterlockedExchangeAdd(value, 1)
    #define __pyx_atomic_decr_acq_rel(value) _InterlockedExchangeAdd(value, -1)
    #define __pyx_atomic_sub(value, arg) _InterlockedExchangeAdd(value, -arg)
    static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) {
        __pyx_nonatomic_int_type old = _InterlockedCompareExchange(value, desired, *expected);
        int result = old == *expected;
        *expected = old;
        return result;
    }
    #define __pyx_atomic_load(value) _InterlockedExchangeAdd(value, 0)
    #define __pyx_atomic_store(value, new_value) _InterlockedExchange(value, new_value)
    #define __pyx_atomic_pointer_load_relaxed(value) *(void * volatile *)value
    #define __pyx_atomic_pointer_load_acquire(value) _InterlockedCompareExchangePointer(value, 0, 0)
    #define __pyx_atomic_pointer_exchange(value, new_value) _InterlockedExchangePointer(value, (__pyx_atomic_ptr_type)new_value)
    static CYTHON_INLINE int __pyx_atomic_pointer_cmp_exchange(__pyx_atomic_ptr_type* value, __pyx_nonatomic_ptr_type* expected, __pyx_nonatomic_ptr_type desired) {
        __pyx_atomic_ptr_type old = _InterlockedCompareExchangePointer(value, desired, *expected);
        int result = old == *expected;
        *expected = old;
        return result;
    }
    #ifdef __PYX_DEBUG_ATOMICS
        #pragma message ("Using MSVC atomics")
    #endif
#else
    #undef CYTHON_ATOMICS
    #define CYTHON_ATOMICS 0
    #ifdef __PYX_DEBUG_ATOMICS
        #warning "Not using atomics"
    #endif
#endif

/* CriticalSectionsDefinition.proto (used by CriticalSections) */
#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
#define __Pyx_PyCriticalSection void*
#define __Pyx_PyCriticalSection2 void*
#define __Pyx_PyCriticalSection_End(cs)
#define __Pyx_PyCriticalSection2_End(cs)
#else
#define __Pyx_PyCriticalSection PyCriticalSection
#define __Pyx_PyCriticalSection2 PyCriticalSection2
#define __Pyx_PyCriticalSection_End PyCriticalSection_End
#define __Pyx_PyCriticalSection2_End PyCriticalSection2_End
#endif

/* CriticalSections.proto (used by ParseKeywordsImpl) */
#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
#define __Pyx_PyCriticalSection_Begin(cs, arg) (void)(cs)
#define __Pyx_PyCriticalSection2_Begin(cs, arg1, arg2) (void)(cs)
#else
#define __Pyx_PyCriticalSection_Begin PyCriticalSection_Begin
#define __Pyx_PyCriticalSection2_Begin PyCriticalSection2_Begin
#endif
#if PY_VERSION_HEX < 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API
#define __Pyx_BEGIN_CRITICAL_SECTION(o) {
#define __Pyx_END_CRITICAL_SECTION() }
#else
#define __Pyx_BEGIN_CRITICAL_SECTION Py_BEGIN_CRITICAL_SECTION
#define __Pyx_END_CRITICAL_SECTION Py_END_CRITICAL_SECTION
#endif

/* IncludeStructmemberH.proto (used by FixUpExtensionType) */
#include <structmember.h>

/* #### Code section: numeric_typedefs ### */

/* "cy_nvml.pxd":746
 *     unsigned char moduleId
 * 
 * ctypedef unsigned int nvmlDeviceArchitecture_t 'nvmlDeviceArchitecture_t'             # <<<<<<<<<<<<<<
 * ctypedef unsigned int nvmlBusType_t 'nvmlBusType_t'
 * ctypedef unsigned int nvmlFanControlPolicy_t 'nvmlFanControlPolicy_t'
*/
typedef unsigned int nvmlDeviceArchitecture_t;

/* "cy_nvml.pxd":747
 * 
 * ctypedef unsigned int nvmlDeviceArchitecture_t 'nvmlDeviceArchitecture_t'
 * ctypedef unsigned int nvmlBusType_t 'nvmlBusType_t'             # <<<<<<<<<<<<<<
 * ctypedef unsigned int nvmlFanControlPolicy_t 'nvmlFanControlPolicy_t'
 * ctypedef unsigned int nvmlPowerSource_t 'nvmlPowerSource_t'
*/
typedef unsigned int nvmlBusType_t;

/* "cy_nvml.pxd":748
 * ctypedef unsigned int nvmlDeviceArchitecture_t 'nvmlDeviceArchitecture_t'
 * ctypedef unsigned int nvmlBusType_t 'nvmlBusType_t'
 * ctypedef unsigned int nvmlFanControlPolicy_t 'nvmlFanControlPolicy_t'             # <<<<<<<<<<<<<<
 * ctypedef unsigned int nvmlPowerSource_t 'nvmlPowerSource_t'
 * ctypedef unsigned char nvmlPowerScopeType_t 'nvmlPowerScopeType_t'
*/
typedef unsigned int nvmlFanControlPolicy_t;

/* "cy_nvml.pxd":749
 * ctypedef unsigned int nvmlBusType_t 'nvmlBusType_t'
 * ctypedef unsigned int nvmlFanControlPolicy_t 'nvmlFanControlPolicy_t'
 * ctypedef unsigned int nvmlPowerSource_t 'nvmlPowerSource_t'             # <<<<<<<<<<<<<<
 * ctypedef unsigned char nvmlPowerScopeType_t 'nvmlPowerScopeType_t'
 * ctypedef unsigned int nvmlVgpuTypeId_t 'nvmlVgpuTypeId_t'
*/
typedef unsigned int nvmlPowerSource_t;

/* "cy_nvml.pxd":750
 * ctypedef unsigned int nvmlFanControlPolicy_t 'nvmlFanControlPolicy_t'
 * ctypedef unsigned int nvmlPowerSource_t 'nvmlPowerSource_t'
 * ctypedef unsigned char nvmlPowerScopeType_t 'nvmlPowerScopeType_t'             # <<<<<<<<<<<<<<
 * ctypedef unsigned int nvmlVgpuTypeId_t 'nvmlVgpuTypeId_t'
 * ctypedef unsigned int nvmlVgpuInstance_t 'nvmlVgpuInstance_t'
*/
typedef unsigned char nvmlPowerScopeType_t;

/* "cy_nvml.pxd":751
 * ctypedef unsigned int nvmlPowerSource_t 'nvmlPowerSource_t'
 * ctypedef unsigned char nvmlPowerScopeType_t 'nvmlPowerScopeType_t'
 * ctypedef unsigned int nvmlVgpuTypeId_t 'nvmlVgpuTypeId_t'             # <<<<<<<<<<<<<<
 * ctypedef unsigned int nvmlVgpuInstance_t 'nvmlVgpuInstance_t'
 * ctypedef struct nvmlVgpuHeterogeneousMode_v1_t 'nvmlVgpuHeterogeneousMode_v1_t':
*/
typedef unsigned int nvmlVgpuTypeId_t;

/* "cy_nvml.pxd":752
 * ctypedef unsigned char nvmlPowerScopeType_t 'nvmlPowerScopeType_t'
 * ctypedef unsigned int nvmlVgpuTypeId_t 'nvmlVgpuTypeId_t'
 * ctypedef unsigned int nvmlVgpuInstance_t 'nvmlVgpuInstance_t'             # <<<<<<<<<<<<<<
 * ctypedef struct nvmlVgpuHeterogeneousMode_v1_t 'nvmlVgpuHeterogeneousMode_v1_t':
 *     unsigned int version
*/
typedef unsigned int nvmlVgpuInstance_t;

/* "cy_nvml.pxd":791
 *     unsigned long long attackerAdvantage
 * 
 * ctypedef unsigned char nvmlGpuFabricState_t 'nvmlGpuFabricState_t'             # <<<<<<<<<<<<<<
 * ctypedef struct nvmlSystemDriverBranchInfo_v1_t 'nvmlSystemDriverBranchInfo_v1_t':
 *     unsigned int version
*/
typedef unsigned char nvmlGpuFabricState_t;

/* "cy_nvml.pxd":796
 *     char branch[80]
 * 
 * ctypedef unsigned int nvmlAffinityScope_t 'nvmlAffinityScope_t'             # <<<<<<<<<<<<<<
 * ctypedef struct nvmlTemperature_v1_t 'nvmlTemperature_v1_t':
 *     unsigned int version
*/
typedef unsigned int nvmlAffinityScope_t;
/* #### Code section: complex_type_declarations ### */
/* #### Code section: type_declarations ### */

/*--- Type declarations ---*/
struct nvmlPciInfoExt_v1_t;
typedef struct nvmlPciInfoExt_v1_t nvmlPciInfoExt_v1_t;
struct nvmlCoolerInfo_v1_t;
typedef struct nvmlCoolerInfo_v1_t nvmlCoolerInfo_v1_t;
struct nvmlDramEncryptionInfo_v1_t;
typedef struct nvmlDramEncryptionInfo_v1_t nvmlDramEncryptionInfo_v1_t;
struct nvmlMarginTemperature_v1_t;
typedef struct nvmlMarginTemperature_v1_t nvmlMarginTemperature_v1_t;
struct nvmlClockOffset_v1_t;
typedef struct nvmlClockOffset_v1_t nvmlClockOffset_v1_t;
struct nvmlFanSpeedInfo_v1_t;
typedef struct nvmlFanSpeedInfo_v1_t nvmlFanSpeedInfo_v1_t;
struct nvmlDevicePerfModes_v1_t;
typedef struct nvmlDevicePerfModes_v1_t nvmlDevicePerfModes_v1_t;
struct nvmlDeviceCurrentClockFreqs_v1_t;
typedef struct nvmlDeviceCurrentClockFreqs_v1_t nvmlDeviceCurrentClockFreqs_v1_t;
struct nvmlEccSramErrorStatus_v1_t;
typedef struct nvmlEccSramErrorStatus_v1_t nvmlEccSramErrorStatus_v1_t;
struct nvmlPlatformInfo_v2_t;
typedef struct nvmlPlatformInfo_v2_t nvmlPlatformInfo_v2_t;
struct nvmlVgpuHeterogeneousMode_v1_t;
typedef struct nvmlVgpuHeterogeneousMode_v1_t nvmlVgpuHeterogeneousMode_v1_t;
struct nvmlVgpuPlacementId_v1_t;
typedef struct nvmlVgpuPlacementId_v1_t nvmlVgpuPlacementId_v1_t;
struct nvmlVgpuPlacementList_v2_t;
typedef struct nvmlVgpuPlacementList_v2_t nvmlVgpuPlacementList_v2_t;
struct nvmlVgpuTypeBar1Info_v1_t;
typedef struct nvmlVgpuTypeBar1Info_v1_t nvmlVgpuTypeBar1Info_v1_t;
struct nvmlVgpuRuntimeState_v1_t;
typedef struct nvmlVgpuRuntimeState_v1_t nvmlVgpuRuntimeState_v1_t;
struct nvmlSystemConfComputeSettings_v1_t;
typedef struct nvmlSystemConfComputeSettings_v1_t nvmlSystemConfComputeSettings_v1_t;
struct nvmlConfComputeSetKeyRotationThresholdInfo_v1_t;
typedef struct nvmlConfComputeSetKeyRotationThresholdInfo_v1_t nvmlConfComputeSetKeyRotationThresholdInfo_v1_t;
struct nvmlConfComputeGetKeyRotationThresholdInfo_v1_t;
typedef struct nvmlConfComputeGetKeyRotationThresholdInfo_v1_t nvmlConfComputeGetKeyRotationThresholdInfo_v1_t;
struct nvmlSystemDriverBranchInfo_v1_t;
typedef struct nvmlSystemDriverBranchInfo_v1_t nvmlSystemDriverBranchInfo_v1_t;
struct nvmlTemperature_v1_t;
typedef struct nvmlTemperature_v1_t nvmlTemperature_v1_t;
struct nvmlNvlinkSupportedBwModes_v1_t;
typedef struct nvmlNvlinkSupportedBwModes_v1_t nvmlNvlinkSupportedBwModes_v1_t;
struct nvmlNvlinkGetBwMode_v1_t;
typedef struct nvmlNvlinkGetBwMode_v1_t nvmlNvlinkGetBwMode_v1_t;
struct nvmlNvlinkSetBwMode_v1_t;
typedef struct nvmlNvlinkSetBwMode_v1_t nvmlNvlinkSetBwMode_v1_t;
struct nvmlDeviceCapabilities_v1_t;
typedef struct nvmlDeviceCapabilities_v1_t nvmlDeviceCapabilities_v1_t;
struct nvmlPowerSmoothingProfile_v1_t;
typedef struct nvmlPowerSmoothingProfile_v1_t nvmlPowerSmoothingProfile_v1_t;
struct nvmlPowerSmoothingState_v1_t;
typedef struct nvmlPowerSmoothingState_v1_t nvmlPowerSmoothingState_v1_t;
struct nvmlDeviceAddressingMode_v1_t;
typedef struct nvmlDeviceAddressingMode_v1_t nvmlDeviceAddressingMode_v1_t;
struct nvmlRepairStatus_v1_t;
typedef struct nvmlRepairStatus_v1_t nvmlRepairStatus_v1_t;
struct nvmlPdi_v1_t;
typedef struct nvmlPdi_v1_t nvmlPdi_v1_t;
struct nvmlPciInfo_t;
typedef struct nvmlPciInfo_t nvmlPciInfo_t;
struct nvmlEccErrorCounts_t;
typedef struct nvmlEccErrorCounts_t nvmlEccErrorCounts_t;
struct nvmlUtilization_t;
typedef struct nvmlUtilization_t nvmlUtilization_t;
struct nvmlMemory_t;
typedef struct nvmlMemory_t nvmlMemory_t;
struct nvmlMemory_v2_t;
typedef struct nvmlMemory_v2_t nvmlMemory_v2_t;
struct nvmlBAR1Memory_t;
typedef struct nvmlBAR1Memory_t nvmlBAR1Memory_t;
struct nvmlProcessInfo_v1_t;
typedef struct nvmlProcessInfo_v1_t nvmlProcessInfo_v1_t;
struct nvmlProcessInfo_v2_t;
typedef struct nvmlProcessInfo_v2_t nvmlProcessInfo_v2_t;
struct nvmlProcessInfo_t;
typedef struct nvmlProcessInfo_t nvmlProcessInfo_t;
struct nvmlProcessDetail_v1_t;
typedef struct nvmlProcessDetail_v1_t nvmlProcessDetail_v1_t;
struct nvmlDeviceAttributes_t;
typedef struct nvmlDeviceAttributes_t nvmlDeviceAttributes_t;
struct nvmlC2cModeInfo_v1_t;
typedef struct nvmlC2cModeInfo_v1_t nvmlC2cModeInfo_v1_t;
struct nvmlRowRemapperHistogramValues_t;
typedef struct nvmlRowRemapperHistogramValues_t nvmlRowRemapperHistogramValues_t;
struct nvmlNvLinkUtilizationControl_t;
typedef struct nvmlNvLinkUtilizationControl_t nvmlNvLinkUtilizationControl_t;
struct nvmlBridgeChipInfo_t;
typedef struct nvmlBridgeChipInfo_t nvmlBridgeChipInfo_t;
union nvmlValue_t;
typedef union nvmlValue_t nvmlValue_t;
struct nvmlViolationTime_t;
typedef struct nvmlViolationTime_t nvmlViolationTime_t;
struct _anon_pod0;
typedef struct _anon_pod0 _anon_pod0;
union nvmlUUIDValue_t;
typedef union nvmlUUIDValue_t nvmlUUIDValue_t;
struct nvmlClkMonFaultInfo_t;
typedef struct nvmlClkMonFaultInfo_t nvmlClkMonFaultInfo_t;
struct nvmlProcessUtilizationSample_t;
typedef struct nvmlProcessUtilizationSample_t nvmlProcessUtilizationSample_t;
struct nvmlProcessUtilizationInfo_v1_t;
typedef struct nvmlProcessUtilizationInfo_v1_t nvmlProcessUtilizationInfo_v1_t;
struct nvmlPlatformInfo_v1_t;
typedef struct nvmlPlatformInfo_v1_t nvmlPlatformInfo_v1_t;
struct _anon_pod1;
typedef struct _anon_pod1 _anon_pod1;
struct nvmlVgpuPlacementList_v1_t;
typedef struct nvmlVgpuPlacementList_v1_t nvmlVgpuPlacementList_v1_t;
struct _anon_pod2;
typedef struct _anon_pod2 _anon_pod2;
struct _anon_pod3;
typedef struct _anon_pod3 _anon_pod3;
struct nvmlVgpuSchedulerLogEntry_t;
typedef struct nvmlVgpuSchedulerLogEntry_t nvmlVgpuSchedulerLogEntry_t;
struct _anon_pod4;
typedef struct _anon_pod4 _anon_pod4;
struct _anon_pod5;
typedef struct _anon_pod5 _anon_pod5;
struct nvmlVgpuSchedulerCapabilities_t;
typedef struct nvmlVgpuSchedulerCapabilities_t nvmlVgpuSchedulerCapabilities_t;
struct nvmlVgpuLicenseExpiry_t;
typedef struct nvmlVgpuLicenseExpiry_t nvmlVgpuLicenseExpiry_t;
struct nvmlGridLicenseExpiry_t;
typedef struct nvmlGridLicenseExpiry_t nvmlGridLicenseExpiry_t;
struct nvmlNvLinkPowerThres_t;
typedef struct nvmlNvLinkPowerThres_t nvmlNvLinkPowerThres_t;
struct nvmlHwbcEntry_t;
typedef struct nvmlHwbcEntry_t nvmlHwbcEntry_t;
struct nvmlLedState_t;
typedef struct nvmlLedState_t nvmlLedState_t;
struct nvmlUnitInfo_t;
typedef struct nvmlUnitInfo_t nvmlUnitInfo_t;
struct nvmlPSUInfo_t;
typedef struct nvmlPSUInfo_t nvmlPSUInfo_t;
struct nvmlUnitFanInfo_t;
typedef struct nvmlUnitFanInfo_t nvmlUnitFanInfo_t;
struct nvmlSystemEventData_v1_t;
typedef struct nvmlSystemEventData_v1_t nvmlSystemEventData_v1_t;
struct nvmlAccountingStats_t;
typedef struct nvmlAccountingStats_t nvmlAccountingStats_t;
struct nvmlFBCStats_t;
typedef struct nvmlFBCStats_t nvmlFBCStats_t;
struct nvmlConfComputeSystemCaps_t;
typedef struct nvmlConfComputeSystemCaps_t nvmlConfComputeSystemCaps_t;
struct nvmlConfComputeSystemState_t;
typedef struct nvmlConfComputeSystemState_t nvmlConfComputeSystemState_t;
struct nvmlConfComputeMemSizeInfo_t;
typedef struct nvmlConfComputeMemSizeInfo_t nvmlConfComputeMemSizeInfo_t;
struct nvmlConfComputeGpuCertificate_t;
typedef struct nvmlConfComputeGpuCertificate_t nvmlConfComputeGpuCertificate_t;
struct nvmlConfComputeGpuAttestationReport_t;
typedef struct nvmlConfComputeGpuAttestationReport_t nvmlConfComputeGpuAttestationReport_t;
struct nvmlVgpuVersion_t;
typedef struct nvmlVgpuVersion_t nvmlVgpuVersion_t;
struct nvmlVgpuMetadata_t;
typedef struct nvmlVgpuMetadata_t nvmlVgpuMetadata_t;
struct nvmlVgpuPgpuCompatibility_t;
typedef struct nvmlVgpuPgpuCompatibility_t nvmlVgpuPgpuCompatibility_t;
struct nvmlGpuInstancePlacement_t;
typedef struct nvmlGpuInstancePlacement_t nvmlGpuInstancePlacement_t;
struct nvmlGpuInstanceProfileInfo_t;
typedef struct nvmlGpuInstanceProfileInfo_t nvmlGpuInstanceProfileInfo_t;
struct nvmlGpuInstanceProfileInfo_v2_t;
typedef struct nvmlGpuInstanceProfileInfo_v2_t nvmlGpuInstanceProfileInfo_v2_t;
struct nvmlGpuInstanceProfileInfo_v3_t;
typedef struct nvmlGpuInstanceProfileInfo_v3_t nvmlGpuInstanceProfileInfo_v3_t;
struct nvmlComputeInstancePlacement_t;
typedef struct nvmlComputeInstancePlacement_t nvmlComputeInstancePlacement_t;
struct nvmlComputeInstanceProfileInfo_t;
typedef struct nvmlComputeInstanceProfileInfo_t nvmlComputeInstanceProfileInfo_t;
struct nvmlComputeInstanceProfileInfo_v2_t;
typedef struct nvmlComputeInstanceProfileInfo_v2_t nvmlComputeInstanceProfileInfo_v2_t;
struct nvmlComputeInstanceProfileInfo_v3_t;
typedef struct nvmlComputeInstanceProfileInfo_v3_t nvmlComputeInstanceProfileInfo_v3_t;
struct _anon_pod6;
typedef struct _anon_pod6 _anon_pod6;
struct nvmlGpmSupport_t;
typedef struct nvmlGpmSupport_t nvmlGpmSupport_t;
struct nvmlMask255_t;
typedef struct nvmlMask255_t nvmlMask255_t;
struct nvmlDevicePowerMizerModes_v1_t;
typedef struct nvmlDevicePowerMizerModes_v1_t nvmlDevicePowerMizerModes_v1_t;
struct nvmlHostname_v1_t;
typedef struct nvmlHostname_v1_t nvmlHostname_v1_t;
struct nvmlEccSramUniqueUncorrectedErrorEntry_v1_t;
typedef struct nvmlEccSramUniqueUncorrectedErrorEntry_v1_t nvmlEccSramUniqueUncorrectedErrorEntry_v1_t;
struct nvmlNvLinkInfo_v1_t;
typedef struct nvmlNvLinkInfo_v1_t nvmlNvLinkInfo_v1_t;
struct nvmlNvlinkFirmwareVersion_t;
typedef struct nvmlNvlinkFirmwareVersion_t nvmlNvlinkFirmwareVersion_t;
union _anon_pod7;
typedef union _anon_pod7 _anon_pod7;
struct nvmlPowerValue_v2_t;
typedef struct nvmlPowerValue_v2_t nvmlPowerValue_v2_t;
struct nvmlVgpuTypeIdInfo_v1_t;
typedef struct nvmlVgpuTypeIdInfo_v1_t nvmlVgpuTypeIdInfo_v1_t;
struct nvmlVgpuTypeMaxInstance_v1_t;
typedef struct nvmlVgpuTypeMaxInstance_v1_t nvmlVgpuTypeMaxInstance_v1_t;
struct nvmlVgpuCreatablePlacementInfo_v1_t;
typedef struct nvmlVgpuCreatablePlacementInfo_v1_t nvmlVgpuCreatablePlacementInfo_v1_t;
struct nvmlVgpuProcessUtilizationSample_t;
typedef struct nvmlVgpuProcessUtilizationSample_t nvmlVgpuProcessUtilizationSample_t;
struct nvmlVgpuProcessUtilizationInfo_v1_t;
typedef struct nvmlVgpuProcessUtilizationInfo_v1_t nvmlVgpuProcessUtilizationInfo_v1_t;
struct nvmlActiveVgpuInstanceInfo_v1_t;
typedef struct nvmlActiveVgpuInstanceInfo_v1_t nvmlActiveVgpuInstanceInfo_v1_t;
struct nvmlEncoderSessionInfo_t;
typedef struct nvmlEncoderSessionInfo_t nvmlEncoderSessionInfo_t;
struct nvmlFBCSessionInfo_t;
typedef struct nvmlFBCSessionInfo_t nvmlFBCSessionInfo_t;
struct nvmlGpuFabricInfo_t;
typedef struct nvmlGpuFabricInfo_t nvmlGpuFabricInfo_t;
struct nvmlGpuFabricInfo_v2_t;
typedef struct nvmlGpuFabricInfo_v2_t nvmlGpuFabricInfo_v2_t;
struct nvmlGpuFabricInfo_v3_t;
typedef struct nvmlGpuFabricInfo_v3_t nvmlGpuFabricInfo_v3_t;
struct nvmlEventData_t;
typedef struct nvmlEventData_t nvmlEventData_t;
struct nvmlSystemEventSetCreateRequest_v1_t;
typedef struct nvmlSystemEventSetCreateRequest_v1_t nvmlSystemEventSetCreateRequest_v1_t;
struct nvmlSystemEventSetFreeRequest_v1_t;
typedef struct nvmlSystemEventSetFreeRequest_v1_t nvmlSystemEventSetFreeRequest_v1_t;
struct nvmlSystemRegisterEventRequest_v1_t;
typedef struct nvmlSystemRegisterEventRequest_v1_t nvmlSystemRegisterEventRequest_v1_t;
struct nvmlExcludedDeviceInfo_t;
typedef struct nvmlExcludedDeviceInfo_t nvmlExcludedDeviceInfo_t;
struct nvmlProcessDetailList_v1_t;
typedef struct nvmlProcessDetailList_v1_t nvmlProcessDetailList_v1_t;
struct nvmlBridgeChipHierarchy_t;
typedef struct nvmlBridgeChipHierarchy_t nvmlBridgeChipHierarchy_t;
struct nvmlSample_t;
typedef struct nvmlSample_t nvmlSample_t;
struct nvmlVgpuInstanceUtilizationSample_t;
typedef struct nvmlVgpuInstanceUtilizationSample_t nvmlVgpuInstanceUtilizationSample_t;
struct nvmlVgpuInstanceUtilizationInfo_v1_t;
typedef struct nvmlVgpuInstanceUtilizationInfo_v1_t nvmlVgpuInstanceUtilizationInfo_v1_t;
struct nvmlFieldValue_t;
typedef struct nvmlFieldValue_t nvmlFieldValue_t;
struct nvmlGpuThermalSettings_t;
typedef struct nvmlGpuThermalSettings_t nvmlGpuThermalSettings_t;
struct nvmlUUID_v1_t;
typedef struct nvmlUUID_v1_t nvmlUUID_v1_t;
struct nvmlClkMonStatus_t;
typedef struct nvmlClkMonStatus_t nvmlClkMonStatus_t;
struct nvmlProcessesUtilizationInfo_v1_t;
typedef struct nvmlProcessesUtilizationInfo_v1_t nvmlProcessesUtilizationInfo_v1_t;
struct nvmlGpuDynamicPstatesInfo_t;
typedef struct nvmlGpuDynamicPstatesInfo_t nvmlGpuDynamicPstatesInfo_t;
union nvmlVgpuSchedulerParams_t;
typedef union nvmlVgpuSchedulerParams_t nvmlVgpuSchedulerParams_t;
union nvmlVgpuSchedulerSetParams_t;
typedef union nvmlVgpuSchedulerSetParams_t nvmlVgpuSchedulerSetParams_t;
struct nvmlVgpuLicenseInfo_t;
typedef struct nvmlVgpuLicenseInfo_t nvmlVgpuLicenseInfo_t;
struct nvmlGridLicensableFeature_t;
typedef struct nvmlGridLicensableFeature_t nvmlGridLicensableFeature_t;
struct nvmlUnitFanSpeeds_t;
typedef struct nvmlUnitFanSpeeds_t nvmlUnitFanSpeeds_t;
struct nvmlSystemEventSetWaitRequest_v1_t;
typedef struct nvmlSystemEventSetWaitRequest_v1_t nvmlSystemEventSetWaitRequest_v1_t;
struct nvmlVgpuPgpuMetadata_t;
typedef struct nvmlVgpuPgpuMetadata_t nvmlVgpuPgpuMetadata_t;
struct nvmlGpuInstanceInfo_t;
typedef struct nvmlGpuInstanceInfo_t nvmlGpuInstanceInfo_t;
struct nvmlComputeInstanceInfo_t;
typedef struct nvmlComputeInstanceInfo_t nvmlComputeInstanceInfo_t;
struct nvmlGpmMetric_t;
typedef struct nvmlGpmMetric_t nvmlGpmMetric_t;
struct nvmlWorkloadPowerProfileInfo_v1_t;
typedef struct nvmlWorkloadPowerProfileInfo_v1_t nvmlWorkloadPowerProfileInfo_v1_t;
struct nvmlWorkloadPowerProfileCurrentProfiles_v1_t;
typedef struct nvmlWorkloadPowerProfileCurrentProfiles_v1_t nvmlWorkloadPowerProfileCurrentProfiles_v1_t;
struct nvmlWorkloadPowerProfileRequestedProfiles_v1_t;
typedef struct nvmlWorkloadPowerProfileRequestedProfiles_v1_t nvmlWorkloadPowerProfileRequestedProfiles_v1_t;
struct nvmlEccSramUniqueUncorrectedErrorCounts_v1_t;
typedef struct nvmlEccSramUniqueUncorrectedErrorCounts_v1_t nvmlEccSramUniqueUncorrectedErrorCounts_v1_t;
struct nvmlNvlinkFirmwareInfo_t;
typedef struct nvmlNvlinkFirmwareInfo_t nvmlNvlinkFirmwareInfo_t;
struct nvmlPRMTLV_v1_t;
typedef struct nvmlPRMTLV_v1_t nvmlPRMTLV_v1_t;
struct nvmlVgpuProcessesUtilizationInfo_v1_t;
typedef struct nvmlVgpuProcessesUtilizationInfo_v1_t nvmlVgpuProcessesUtilizationInfo_v1_t;
struct nvmlVgpuInstancesUtilizationInfo_v1_t;
typedef struct nvmlVgpuInstancesUtilizationInfo_v1_t nvmlVgpuInstancesUtilizationInfo_v1_t;
struct nvmlVgpuSchedulerLog_t;
typedef struct nvmlVgpuSchedulerLog_t nvmlVgpuSchedulerLog_t;
struct nvmlVgpuSchedulerGetState_t;
typedef struct nvmlVgpuSchedulerGetState_t nvmlVgpuSchedulerGetState_t;
struct nvmlVgpuSchedulerStateInfo_v1_t;
typedef struct nvmlVgpuSchedulerStateInfo_v1_t nvmlVgpuSchedulerStateInfo_v1_t;
struct nvmlVgpuSchedulerLogInfo_v1_t;
typedef struct nvmlVgpuSchedulerLogInfo_v1_t nvmlVgpuSchedulerLogInfo_v1_t;
struct nvmlVgpuSchedulerSetState_t;
typedef struct nvmlVgpuSchedulerSetState_t nvmlVgpuSchedulerSetState_t;
struct nvmlVgpuSchedulerState_v1_t;
typedef struct nvmlVgpuSchedulerState_v1_t nvmlVgpuSchedulerState_v1_t;
struct nvmlGridLicensableFeatures_t;
typedef struct nvmlGridLicensableFeatures_t nvmlGridLicensableFeatures_t;
struct nvmlGpmMetricsGet_t;
typedef struct nvmlGpmMetricsGet_t nvmlGpmMetricsGet_t;
struct nvmlNvLinkInfo_v2_t;
typedef struct nvmlNvLinkInfo_v2_t nvmlNvLinkInfo_v2_t;
struct nvmlWorkloadPowerProfileProfilesInfo_v1_t;
typedef struct nvmlWorkloadPowerProfileProfilesInfo_v1_t nvmlWorkloadPowerProfileProfilesInfo_v1_t;

/* "cy_nvml.pxd":15
 * 
 * # enums
 * ctypedef enum nvmlBridgeChipType_t "nvmlBridgeChipType_t":             # <<<<<<<<<<<<<<
 *     NVML_BRIDGE_CHIP_PLX "NVML_BRIDGE_CHIP_PLX" = 0
 *     NVML_BRIDGE_CHIP_BRO4 "NVML_BRIDGE_CHIP_BRO4" = 1
*/
enum nvmlBridgeChipType_t {
  NVML_BRIDGE_CHIP_PLX = 0,
  NVML_BRIDGE_CHIP_BRO4 = 1
};
typedef enum nvmlBridgeChipType_t nvmlBridgeChipType_t;

/* "cy_nvml.pxd":19
 *     NVML_BRIDGE_CHIP_BRO4 "NVML_BRIDGE_CHIP_BRO4" = 1
 * 
 * ctypedef enum nvmlNvLinkUtilizationCountUnits_t "nvmlNvLinkUtilizationCountUnits_t":             # <<<<<<<<<<<<<<
 *     NVML_NVLINK_COUNTER_UNIT_CYCLES "NVML_NVLINK_COUNTER_UNIT_CYCLES" = 0
 *     NVML_NVLINK_COUNTER_UNIT_PACKETS "NVML_NVLINK_COUNTER_UNIT_PACKETS" = 1
*/
enum nvmlNvLinkUtilizationCountUnits_t {
  NVML_NVLINK_COUNTER_UNIT_CYCLES = 0,
  NVML_NVLINK_COUNTER_UNIT_PACKETS = 1,
  NVML_NVLINK_COUNTER_UNIT_BYTES = 2,
  NVML_NVLINK_COUNTER_UNIT_RESERVED = 3,
  NVML_NVLINK_COUNTER_UNIT_COUNT
};
typedef enum nvmlNvLinkUtilizationCountUnits_t nvmlNvLinkUtilizationCountUnits_t;

/* "cy_nvml.pxd":26
 *     NVML_NVLINK_COUNTER_UNIT_COUNT "NVML_NVLINK_COUNTER_UNIT_COUNT"
 * 
 * ctypedef enum nvmlNvLinkUtilizationCountPktTypes_t "nvmlNvLinkUtilizationCountPktTypes_t":             # <<<<<<<<<<<<<<
 *     NVML_NVLINK_COUNTER_PKTFILTER_NOP "NVML_NVLINK_COUNTER_PKTFILTER_NOP" = 0x1
 *     NVML_NVLINK_COUNTER_PKTFILTER_READ "NVML_NVLINK_COUNTER_PKTFILTER_READ" = 0x2
*/
enum nvmlNvLinkUtilizationCountPktTypes_t {
  NVML_NVLINK_COUNTER_PKTFILTER_NOP = 0x1,
  NVML_NVLINK_COUNTER_PKTFILTER_READ = 0x2,
  NVML_NVLINK_COUNTER_PKTFILTER_WRITE = 0x4,
  NVML_NVLINK_COUNTER_PKTFILTER_RATOM = 0x8,
  NVML_NVLINK_COUNTER_PKTFILTER_NRATOM = 0x10,
  NVML_NVLINK_COUNTER_PKTFILTER_FLUSH = 0x20,
  NVML_NVLINK_COUNTER_PKTFILTER_RESPDATA = 0x40,
  NVML_NVLINK_COUNTER_PKTFILTER_RESPNODATA = 0x80,
  NVML_NVLINK_COUNTER_PKTFILTER_ALL = 0xFF
};
typedef enum nvmlNvLinkUtilizationCountPktTypes_t nvmlNvLinkUtilizationCountPktTypes_t;

/* "cy_nvml.pxd":37
 *     NVML_NVLINK_COUNTER_PKTFILTER_ALL "NVML_NVLINK_COUNTER_PKTFILTER_ALL" = 0xFF
 * 
 * ctypedef enum nvmlNvLinkCapability_t "nvmlNvLinkCapability_t":             # <<<<<<<<<<<<<<
 *     NVML_NVLINK_CAP_P2P_SUPPORTED "NVML_NVLINK_CAP_P2P_SUPPORTED" = 0
 *     NVML_NVLINK_CAP_SYSMEM_ACCESS "NVML_NVLINK_CAP_SYSMEM_ACCESS" = 1
*/
enum nvmlNvLinkCapability_t {
  NVML_NVLINK_CAP_P2P_SUPPORTED = 0,
  NVML_NVLINK_CAP_SYSMEM_ACCESS = 1,
  NVML_NVLINK_CAP_P2P_ATOMICS = 2,
  NVML_NVLINK_CAP_SYSMEM_ATOMICS = 3,
  NVML_NVLINK_CAP_SLI_BRIDGE = 4,
  NVML_NVLINK_CAP_VALID = 5,
  NVML_NVLINK_CAP_COUNT
};
typedef enum nvmlNvLinkCapability_t nvmlNvLinkCapability_t;

/* "cy_nvml.pxd":46
 *     NVML_NVLINK_CAP_COUNT "NVML_NVLINK_CAP_COUNT"
 * 
 * ctypedef enum nvmlNvLinkErrorCounter_t "nvmlNvLinkErrorCounter_t":             # <<<<<<<<<<<<<<
 *     NVML_NVLINK_ERROR_DL_REPLAY "NVML_NVLINK_ERROR_DL_REPLAY" = 0
 *     NVML_NVLINK_ERROR_DL_RECOVERY "NVML_NVLINK_ERROR_DL_RECOVERY" = 1
*/
enum nvmlNvLinkErrorCounter_t {
  NVML_NVLINK_ERROR_DL_REPLAY = 0,
  NVML_NVLINK_ERROR_DL_RECOVERY = 1,
  NVML_NVLINK_ERROR_DL_CRC_FLIT = 2,
  NVML_NVLINK_ERROR_DL_CRC_DATA = 3,
  NVML_NVLINK_ERROR_DL_ECC_DATA = 4,
  NVML_NVLINK_ERROR_COUNT
};
typedef enum nvmlNvLinkErrorCounter_t nvmlNvLinkErrorCounter_t;

/* "cy_nvml.pxd":54
 *     NVML_NVLINK_ERROR_COUNT "NVML_NVLINK_ERROR_COUNT"
 * 
 * ctypedef enum nvmlIntNvLinkDeviceType_t "nvmlIntNvLinkDeviceType_t":             # <<<<<<<<<<<<<<
 *     NVML_NVLINK_DEVICE_TYPE_GPU "NVML_NVLINK_DEVICE_TYPE_GPU" = 0x00
 *     NVML_NVLINK_DEVICE_TYPE_IBMNPU "NVML_NVLINK_DEVICE_TYPE_IBMNPU" = 0x01
*/
enum nvmlIntNvLinkDeviceType_t {
  NVML_NVLINK_DEVICE_TYPE_GPU = 0x00,
  NVML_NVLINK_DEVICE_TYPE_IBMNPU = 0x01,
  NVML_NVLINK_DEVICE_TYPE_SWITCH = 0x02,
  NVML_NVLINK_DEVICE_TYPE_UNKNOWN = 0xFF
};
typedef enum nvmlIntNvLinkDeviceType_t nvmlIntNvLinkDeviceType_t;

/* "cy_nvml.pxd":60
 *     NVML_NVLINK_DEVICE_TYPE_UNKNOWN "NVML_NVLINK_DEVICE_TYPE_UNKNOWN" = 0xFF
 * 
 * ctypedef enum nvmlGpuTopologyLevel_t "nvmlGpuTopologyLevel_t":             # <<<<<<<<<<<<<<
 *     NVML_TOPOLOGY_INTERNAL "NVML_TOPOLOGY_INTERNAL" = 0
 *     NVML_TOPOLOGY_SINGLE "NVML_TOPOLOGY_SINGLE" = 10
*/
enum nvmlGpuTopologyLevel_t {
  NVML_TOPOLOGY_INTERNAL = 0,
  NVML_TOPOLOGY_SINGLE = 10,
  NVML_TOPOLOGY_MULTIPLE = 20,
  NVML_TOPOLOGY_HOSTBRIDGE = 30,
  NVML_TOPOLOGY_NODE = 40,
  NVML_TOPOLOGY_SYSTEM = 50
};
typedef enum nvmlGpuTopologyLevel_t nvmlGpuTopologyLevel_t;

/* "cy_nvml.pxd":68
 *     NVML_TOPOLOGY_SYSTEM "NVML_TOPOLOGY_SYSTEM" = 50
 * 
 * ctypedef enum nvmlGpuP2PStatus_t "nvmlGpuP2PStatus_t":             # <<<<<<<<<<<<<<
 *     NVML_P2P_STATUS_OK "NVML_P2P_STATUS_OK" = 0
 *     NVML_P2P_STATUS_CHIPSET_NOT_SUPPORED "NVML_P2P_STATUS_CHIPSET_NOT_SUPPORED"
*/
enum nvmlGpuP2PStatus_t {

  /* "cy_nvml.pxd":71
 *     NVML_P2P_STATUS_OK "NVML_P2P_STATUS_OK" = 0
 *     NVML_P2P_STATUS_CHIPSET_NOT_SUPPORED "NVML_P2P_STATUS_CHIPSET_NOT_SUPPORED"
 *     NVML_P2P_STATUS_CHIPSET_NOT_SUPPORTED "NVML_P2P_STATUS_CHIPSET_NOT_SUPPORTED" = NVML_P2P_STATUS_CHIPSET_NOT_SUPPORED             # <<<<<<<<<<<<<<
 *     NVML_P2P_STATUS_GPU_NOT_SUPPORTED "NVML_P2P_STATUS_GPU_NOT_SUPPORTED"
 *     NVML_P2P_STATUS_IOH_TOPOLOGY_NOT_SUPPORTED "NVML_P2P_STATUS_IOH_TOPOLOGY_NOT_SUPPORTED"
*/
  NVML_P2P_STATUS_OK = 0,
  NVML_P2P_STATUS_CHIPSET_NOT_SUPPORED,
  NVML_P2P_STATUS_CHIPSET_NOT_SUPPORTED = NVML_P2P_STATUS_CHIPSET_NOT_SUPPORED,
  NVML_P2P_STATUS_GPU_NOT_SUPPORTED,
  NVML_P2P_STATUS_IOH_TOPOLOGY_NOT_SUPPORTED,
  NVML_P2P_STATUS_DISABLED_BY_REGKEY,
  NVML_P2P_STATUS_NOT_SUPPORTED,
  NVML_P2P_STATUS_UNKNOWN
};
typedef enum nvmlGpuP2PStatus_t nvmlGpuP2PStatus_t;

/* "cy_nvml.pxd":78
 *     NVML_P2P_STATUS_UNKNOWN "NVML_P2P_STATUS_UNKNOWN"
 * 
 * ctypedef enum nvmlGpuP2PCapsIndex_t "nvmlGpuP2PCapsIndex_t":             # <<<<<<<<<<<<<<
 *     NVML_P2P_CAPS_INDEX_READ "NVML_P2P_CAPS_INDEX_READ" = 0
 *     NVML_P2P_CAPS_INDEX_WRITE "NVML_P2P_CAPS_INDEX_WRITE" = 1
*/
enum nvmlGpuP2PCapsIndex_t {

  /* "cy_nvml.pxd":84
 *     NVML_P2P_CAPS_INDEX_ATOMICS "NVML_P2P_CAPS_INDEX_ATOMICS" = 3
 *     NVML_P2P_CAPS_INDEX_PCI "NVML_P2P_CAPS_INDEX_PCI" = 4
 *     NVML_P2P_CAPS_INDEX_PROP "NVML_P2P_CAPS_INDEX_PROP" = NVML_P2P_CAPS_INDEX_PCI             # <<<<<<<<<<<<<<
 *     NVML_P2P_CAPS_INDEX_UNKNOWN "NVML_P2P_CAPS_INDEX_UNKNOWN" = 5
 * 
*/
  NVML_P2P_CAPS_INDEX_READ = 0,
  NVML_P2P_CAPS_INDEX_WRITE = 1,
  NVML_P2P_CAPS_INDEX_NVLINK = 2,
  NVML_P2P_CAPS_INDEX_ATOMICS = 3,
  NVML_P2P_CAPS_INDEX_PCI = 4,
  NVML_P2P_CAPS_INDEX_PROP = NVML_P2P_CAPS_INDEX_PCI,
  NVML_P2P_CAPS_INDEX_UNKNOWN = 5
};
typedef enum nvmlGpuP2PCapsIndex_t nvmlGpuP2PCapsIndex_t;

/* "cy_nvml.pxd":87
 *     NVML_P2P_CAPS_INDEX_UNKNOWN "NVML_P2P_CAPS_INDEX_UNKNOWN" = 5
 * 
 * ctypedef enum nvmlSamplingType_t "nvmlSamplingType_t":             # <<<<<<<<<<<<<<
 *     NVML_TOTAL_POWER_SAMPLES "NVML_TOTAL_POWER_SAMPLES" = 0
 *     NVML_GPU_UTILIZATION_SAMPLES "NVML_GPU_UTILIZATION_SAMPLES" = 1
*/
enum nvmlSamplingType_t {
  NVML_TOTAL_POWER_SAMPLES = 0,
  NVML_GPU_UTILIZATION_SAMPLES = 1,
  NVML_MEMORY_UTILIZATION_SAMPLES = 2,
  NVML_ENC_UTILIZATION_SAMPLES = 3,
  NVML_DEC_UTILIZATION_SAMPLES = 4,
  NVML_PROCESSOR_CLK_SAMPLES = 5,
  NVML_MEMORY_CLK_SAMPLES = 6,
  NVML_MODULE_POWER_SAMPLES = 7,
  NVML_JPG_UTILIZATION_SAMPLES = 8,
  NVML_OFA_UTILIZATION_SAMPLES = 9,
  NVML_SAMPLINGTYPE_COUNT
};
typedef enum nvmlSamplingType_t nvmlSamplingType_t;

/* "cy_nvml.pxd":100
 *     NVML_SAMPLINGTYPE_COUNT "NVML_SAMPLINGTYPE_COUNT"
 * 
 * ctypedef enum nvmlPcieUtilCounter_t "nvmlPcieUtilCounter_t":             # <<<<<<<<<<<<<<
 *     NVML_PCIE_UTIL_TX_BYTES "NVML_PCIE_UTIL_TX_BYTES" = 0
 *     NVML_PCIE_UTIL_RX_BYTES "NVML_PCIE_UTIL_RX_BYTES" = 1
*/
enum nvmlPcieUtilCounter_t {
  NVML_PCIE_UTIL_TX_BYTES = 0,
  NVML_PCIE_UTIL_RX_BYTES = 1,
  NVML_PCIE_UTIL_COUNT
};
typedef enum nvmlPcieUtilCounter_t nvmlPcieUtilCounter_t;

/* "cy_nvml.pxd":105
 *     NVML_PCIE_UTIL_COUNT "NVML_PCIE_UTIL_COUNT"
 * 
 * ctypedef enum nvmlValueType_t "nvmlValueType_t":             # <<<<<<<<<<<<<<
 *     NVML_VALUE_TYPE_DOUBLE "NVML_VALUE_TYPE_DOUBLE" = 0
 *     NVML_VALUE_TYPE_UNSIGNED_INT "NVML_VALUE_TYPE_UNSIGNED_INT" = 1
*/
enum nvmlValueType_t {
  NVML_VALUE_TYPE_DOUBLE = 0,
  NVML_VALUE_TYPE_UNSIGNED_INT = 1,
  NVML_VALUE_TYPE_UNSIGNED_LONG = 2,
  NVML_VALUE_TYPE_UNSIGNED_LONG_LONG = 3,
  NVML_VALUE_TYPE_SIGNED_LONG_LONG = 4,
  NVML_VALUE_TYPE_SIGNED_INT = 5,
  NVML_VALUE_TYPE_UNSIGNED_SHORT = 6,
  NVML_VALUE_TYPE_COUNT
};
typedef enum nvmlValueType_t nvmlValueType_t;

/* "cy_nvml.pxd":115
 *     NVML_VALUE_TYPE_COUNT "NVML_VALUE_TYPE_COUNT"
 * 
 * ctypedef enum nvmlPerfPolicyType_t "nvmlPerfPolicyType_t":             # <<<<<<<<<<<<<<
 *     NVML_PERF_POLICY_POWER "NVML_PERF_POLICY_POWER" = 0
 *     NVML_PERF_POLICY_THERMAL "NVML_PERF_POLICY_THERMAL" = 1
*/
enum nvmlPerfPolicyType_t {
  NVML_PERF_POLICY_POWER = 0,
  NVML_PERF_POLICY_THERMAL = 1,
  NVML_PERF_POLICY_SYNC_BOOST = 2,
  NVML_PERF_POLICY_BOARD_LIMIT = 3,
  NVML_PERF_POLICY_LOW_UTILIZATION = 4,
  NVML_PERF_POLICY_RELIABILITY = 5,
  NVML_PERF_POLICY_TOTAL_APP_CLOCKS = 10,
  NVML_PERF_POLICY_TOTAL_BASE_CLOCKS = 11,
  NVML_PERF_POLICY_COUNT
};
typedef enum nvmlPerfPolicyType_t nvmlPerfPolicyType_t;

/* "cy_nvml.pxd":126
 *     NVML_PERF_POLICY_COUNT "NVML_PERF_POLICY_COUNT"
 * 
 * ctypedef enum nvmlThermalTarget_t "nvmlThermalTarget_t":             # <<<<<<<<<<<<<<
 *     NVML_THERMAL_TARGET_NONE "NVML_THERMAL_TARGET_NONE" = 0
 *     NVML_THERMAL_TARGET_GPU "NVML_THERMAL_TARGET_GPU" = 1
*/
enum nvmlThermalTarget_t {
  NVML_THERMAL_TARGET_NONE = 0,
  NVML_THERMAL_TARGET_GPU = 1,
  NVML_THERMAL_TARGET_MEMORY = 2,
  NVML_THERMAL_TARGET_POWER_SUPPLY = 4,
  NVML_THERMAL_TARGET_BOARD = 8,
  NVML_THERMAL_TARGET_VCD_BOARD = 9,
  NVML_THERMAL_TARGET_VCD_INLET = 10,
  NVML_THERMAL_TARGET_VCD_OUTLET = 11,
  NVML_THERMAL_TARGET_ALL = 15,
  NVML_THERMAL_TARGET_UNKNOWN = -1L
};
typedef enum nvmlThermalTarget_t nvmlThermalTarget_t;

/* "cy_nvml.pxd":138
 *     NVML_THERMAL_TARGET_UNKNOWN "NVML_THERMAL_TARGET_UNKNOWN" = -(1)
 * 
 * ctypedef enum nvmlThermalController_t "nvmlThermalController_t":             # <<<<<<<<<<<<<<
 *     NVML_THERMAL_CONTROLLER_NONE "NVML_THERMAL_CONTROLLER_NONE" = 0
 *     NVML_THERMAL_CONTROLLER_GPU_INTERNAL "NVML_THERMAL_CONTROLLER_GPU_INTERNAL"
*/
enum nvmlThermalController_t {
  NVML_THERMAL_CONTROLLER_NONE = 0,
  NVML_THERMAL_CONTROLLER_GPU_INTERNAL,
  NVML_THERMAL_CONTROLLER_ADM1032,
  NVML_THERMAL_CONTROLLER_ADT7461,
  NVML_THERMAL_CONTROLLER_MAX6649,
  NVML_THERMAL_CONTROLLER_MAX1617,
  NVML_THERMAL_CONTROLLER_LM99,
  NVML_THERMAL_CONTROLLER_LM89,
  NVML_THERMAL_CONTROLLER_LM64,
  NVML_THERMAL_CONTROLLER_G781,
  NVML_THERMAL_CONTROLLER_ADT7473,
  NVML_THERMAL_CONTROLLER_SBMAX6649,
  NVML_THERMAL_CONTROLLER_VBIOSEVT,
  NVML_THERMAL_CONTROLLER_OS,
  NVML_THERMAL_CONTROLLER_NVSYSCON_CANOAS,
  NVML_THERMAL_CONTROLLER_NVSYSCON_E551,
  NVML_THERMAL_CONTROLLER_MAX6649R,
  NVML_THERMAL_CONTROLLER_ADT7473S,
  NVML_THERMAL_CONTROLLER_UNKNOWN = -1L
};
typedef enum nvmlThermalController_t nvmlThermalController_t;

/* "cy_nvml.pxd":159
 *     NVML_THERMAL_CONTROLLER_UNKNOWN "NVML_THERMAL_CONTROLLER_UNKNOWN" = -(1)
 * 
 * ctypedef enum nvmlCoolerControl_t "nvmlCoolerControl_t":             # <<<<<<<<<<<<<<
 *     NVML_THERMAL_COOLER_SIGNAL_NONE "NVML_THERMAL_COOLER_SIGNAL_NONE" = 0
 *     NVML_THERMAL_COOLER_SIGNAL_TOGGLE "NVML_THERMAL_COOLER_SIGNAL_TOGGLE" = 1
*/
enum nvmlCoolerControl_t {
  NVML_THERMAL_COOLER_SIGNAL_NONE = 0,
  NVML_THERMAL_COOLER_SIGNAL_TOGGLE = 1,
  NVML_THERMAL_COOLER_SIGNAL_VARIABLE = 2,
  NVML_THERMAL_COOLER_SIGNAL_COUNT
};
typedef enum nvmlCoolerControl_t nvmlCoolerControl_t;

/* "cy_nvml.pxd":165
 *     NVML_THERMAL_COOLER_SIGNAL_COUNT "NVML_THERMAL_COOLER_SIGNAL_COUNT"
 * 
 * ctypedef enum nvmlCoolerTarget_t "nvmlCoolerTarget_t":             # <<<<<<<<<<<<<<
 *     NVML_THERMAL_COOLER_TARGET_NONE "NVML_THERMAL_COOLER_TARGET_NONE" = (1 << 0)
 *     NVML_THERMAL_COOLER_TARGET_GPU "NVML_THERMAL_COOLER_TARGET_GPU" = (1 << 1)
*/
enum nvmlCoolerTarget_t {

  /* "cy_nvml.pxd":170
 *     NVML_THERMAL_COOLER_TARGET_MEMORY "NVML_THERMAL_COOLER_TARGET_MEMORY" = (1 << 2)
 *     NVML_THERMAL_COOLER_TARGET_POWER_SUPPLY "NVML_THERMAL_COOLER_TARGET_POWER_SUPPLY" = (1 << 3)
 *     NVML_THERMAL_COOLER_TARGET_GPU_RELATED "NVML_THERMAL_COOLER_TARGET_GPU_RELATED" = ((NVML_THERMAL_COOLER_TARGET_GPU | NVML_THERMAL_COOLER_TARGET_MEMORY) | NVML_THERMAL_COOLER_TARGET_POWER_SUPPLY)             # <<<<<<<<<<<<<<
 * 
 * ctypedef enum nvmlUUIDType_t "nvmlUUIDType_t":
*/
  NVML_THERMAL_COOLER_TARGET_NONE = (1 << 0),
  NVML_THERMAL_COOLER_TARGET_GPU = (1 << 1),
  NVML_THERMAL_COOLER_TARGET_MEMORY = (1 << 2),
  NVML_THERMAL_COOLER_TARGET_POWER_SUPPLY = (1 << 3),
  NVML_THERMAL_COOLER_TARGET_GPU_RELATED = ((NVML_THERMAL_COOLER_TARGET_GPU | NVML_THERMAL_COOLER_TARGET_MEMORY) | NVML_THERMAL_COOLER_TARGET_POWER_SUPPLY)
};
typedef enum nvmlCoolerTarget_t nvmlCoolerTarget_t;

/* "cy_nvml.pxd":172
 *     NVML_THERMAL_COOLER_TARGET_GPU_RELATED "NVML_THERMAL_COOLER_TARGET_GPU_RELATED" = ((NVML_THERMAL_COOLER_TARGET_GPU | NVML_THERMAL_COOLER_TARGET_MEMORY) | NVML_THERMAL_COOLER_TARGET_POWER_SUPPLY)
 * 
 * ctypedef enum nvmlUUIDType_t "nvmlUUIDType_t":             # <<<<<<<<<<<<<<
 *     NVML_UUID_TYPE_NONE "NVML_UUID_TYPE_NONE" = 0
 *     NVML_UUID_TYPE_ASCII "NVML_UUID_TYPE_ASCII" = 1
*/
enum nvmlUUIDType_t {
  NVML_UUID_TYPE_NONE = 0,
  NVML_UUID_TYPE_ASCII = 1,
  NVML_UUID_TYPE_BINARY = 2
};
typedef enum nvmlUUIDType_t nvmlUUIDType_t;

/* "cy_nvml.pxd":177
 *     NVML_UUID_TYPE_BINARY "NVML_UUID_TYPE_BINARY" = 2
 * 
 * ctypedef enum nvmlEnableState_t "nvmlEnableState_t":             # <<<<<<<<<<<<<<
 *     NVML_FEATURE_DISABLED "NVML_FEATURE_DISABLED" = 0
 *     NVML_FEATURE_ENABLED "NVML_FEATURE_ENABLED" = 1
*/
enum nvmlEnableState_t {
  NVML_FEATURE_DISABLED = 0,
  NVML_FEATURE_ENABLED = 1
};
typedef enum nvmlEnableState_t nvmlEnableState_t;

/* "cy_nvml.pxd":181
 *     NVML_FEATURE_ENABLED "NVML_FEATURE_ENABLED" = 1
 * 
 * ctypedef enum nvmlBrandType_t "nvmlBrandType_t":             # <<<<<<<<<<<<<<
 *     NVML_BRAND_UNKNOWN "NVML_BRAND_UNKNOWN" = 0
 *     NVML_BRAND_QUADRO "NVML_BRAND_QUADRO" = 1
*/
enum nvmlBrandType_t {

  /* "cy_nvml.pxd":194
 *     NVML_BRAND_NVIDIA_VWS "NVML_BRAND_NVIDIA_VWS" = 10
 *     NVML_BRAND_NVIDIA_CLOUD_GAMING "NVML_BRAND_NVIDIA_CLOUD_GAMING" = 11
 *     NVML_BRAND_NVIDIA_VGAMING "NVML_BRAND_NVIDIA_VGAMING" = NVML_BRAND_NVIDIA_CLOUD_GAMING             # <<<<<<<<<<<<<<
 *     NVML_BRAND_QUADRO_RTX "NVML_BRAND_QUADRO_RTX" = 12
 *     NVML_BRAND_NVIDIA_RTX "NVML_BRAND_NVIDIA_RTX" = 13
*/
  NVML_BRAND_UNKNOWN = 0,
  NVML_BRAND_QUADRO = 1,
  NVML_BRAND_TESLA = 2,
  NVML_BRAND_NVS = 3,
  NVML_BRAND_GRID = 4,
  NVML_BRAND_GEFORCE = 5,
  NVML_BRAND_TITAN = 6,
  NVML_BRAND_NVIDIA_VAPPS = 7,
  NVML_BRAND_NVIDIA_VPC = 8,
  NVML_BRAND_NVIDIA_VCS = 9,
  NVML_BRAND_NVIDIA_VWS = 10,
  NVML_BRAND_NVIDIA_CLOUD_GAMING = 11,
  NVML_BRAND_NVIDIA_VGAMING = NVML_BRAND_NVIDIA_CLOUD_GAMING,
  NVML_BRAND_QUADRO_RTX = 12,
  NVML_BRAND_NVIDIA_RTX = 13,
  NVML_BRAND_NVIDIA = 14,
  NVML_BRAND_GEFORCE_RTX = 15,
  NVML_BRAND_TITAN_RTX = 16,
  NVML_BRAND_COUNT = 18
};
typedef enum nvmlBrandType_t nvmlBrandType_t;

/* "cy_nvml.pxd":202
 *     NVML_BRAND_COUNT "NVML_BRAND_COUNT" = 18
 * 
 * ctypedef enum nvmlTemperatureThresholds_t "nvmlTemperatureThresholds_t":             # <<<<<<<<<<<<<<
 *     NVML_TEMPERATURE_THRESHOLD_SHUTDOWN "NVML_TEMPERATURE_THRESHOLD_SHUTDOWN" = 0
 *     NVML_TEMPERATURE_THRESHOLD_SLOWDOWN "NVML_TEMPERATURE_THRESHOLD_SLOWDOWN" = 1
*/
enum nvmlTemperatureThresholds_t {
  NVML_TEMPERATURE_THRESHOLD_SHUTDOWN = 0,
  NVML_TEMPERATURE_THRESHOLD_SLOWDOWN = 1,
  NVML_TEMPERATURE_THRESHOLD_MEM_MAX = 2,
  NVML_TEMPERATURE_THRESHOLD_GPU_MAX = 3,
  NVML_TEMPERATURE_THRESHOLD_ACOUSTIC_MIN = 4,
  NVML_TEMPERATURE_THRESHOLD_ACOUSTIC_CURR = 5,
  NVML_TEMPERATURE_THRESHOLD_ACOUSTIC_MAX = 6,
  NVML_TEMPERATURE_THRESHOLD_GPS_CURR = 7,
  NVML_TEMPERATURE_THRESHOLD_COUNT
};
typedef enum nvmlTemperatureThresholds_t nvmlTemperatureThresholds_t;

/* "cy_nvml.pxd":213
 *     NVML_TEMPERATURE_THRESHOLD_COUNT "NVML_TEMPERATURE_THRESHOLD_COUNT"
 * 
 * ctypedef enum nvmlTemperatureSensors_t "nvmlTemperatureSensors_t":             # <<<<<<<<<<<<<<
 *     NVML_TEMPERATURE_GPU "NVML_TEMPERATURE_GPU" = 0
 *     NVML_TEMPERATURE_COUNT "NVML_TEMPERATURE_COUNT"
*/
enum nvmlTemperatureSensors_t {
  NVML_TEMPERATURE_GPU = 0,
  NVML_TEMPERATURE_COUNT
};
typedef enum nvmlTemperatureSensors_t nvmlTemperatureSensors_t;

/* "cy_nvml.pxd":217
 *     NVML_TEMPERATURE_COUNT "NVML_TEMPERATURE_COUNT"
 * 
 * ctypedef enum nvmlComputeMode_t "nvmlComputeMode_t":             # <<<<<<<<<<<<<<
 *     NVML_COMPUTEMODE_DEFAULT "NVML_COMPUTEMODE_DEFAULT" = 0
 *     NVML_COMPUTEMODE_EXCLUSIVE_THREAD "NVML_COMPUTEMODE_EXCLUSIVE_THREAD" = 1
*/
enum nvmlComputeMode_t {
  NVML_COMPUTEMODE_DEFAULT = 0,
  NVML_COMPUTEMODE_EXCLUSIVE_THREAD = 1,
  NVML_COMPUTEMODE_PROHIBITED = 2,
  NVML_COMPUTEMODE_EXCLUSIVE_PROCESS = 3,
  NVML_COMPUTEMODE_COUNT
};
typedef enum nvmlComputeMode_t nvmlComputeMode_t;

/* "cy_nvml.pxd":224
 *     NVML_COMPUTEMODE_COUNT "NVML_COMPUTEMODE_COUNT"
 * 
 * ctypedef enum nvmlMemoryErrorType_t "nvmlMemoryErrorType_t":             # <<<<<<<<<<<<<<
 *     NVML_MEMORY_ERROR_TYPE_CORRECTED "NVML_MEMORY_ERROR_TYPE_CORRECTED" = 0
 *     NVML_MEMORY_ERROR_TYPE_UNCORRECTED "NVML_MEMORY_ERROR_TYPE_UNCORRECTED" = 1
*/
enum nvmlMemoryErrorType_t {
  NVML_MEMORY_ERROR_TYPE_CORRECTED = 0,
  NVML_MEMORY_ERROR_TYPE_UNCORRECTED = 1,
  NVML_MEMORY_ERROR_TYPE_COUNT
};
typedef enum nvmlMemoryErrorType_t nvmlMemoryErrorType_t;

/* "cy_nvml.pxd":229
 *     NVML_MEMORY_ERROR_TYPE_COUNT "NVML_MEMORY_ERROR_TYPE_COUNT"
 * 
 * ctypedef enum nvmlNvlinkVersion_t "nvmlNvlinkVersion_t":             # <<<<<<<<<<<<<<
 *     NVML_NVLINK_VERSION_INVALID "NVML_NVLINK_VERSION_INVALID" = 0
 *     NVML_NVLINK_VERSION_1_0 "NVML_NVLINK_VERSION_1_0" = 1
*/
enum nvmlNvlinkVersion_t {
  NVML_NVLINK_VERSION_INVALID = 0,
  NVML_NVLINK_VERSION_1_0 = 1,
  NVML_NVLINK_VERSION_2_0 = 2,
  NVML_NVLINK_VERSION_2_2 = 3,
  NVML_NVLINK_VERSION_3_0 = 4,
  NVML_NVLINK_VERSION_3_1 = 5,
  NVML_NVLINK_VERSION_4_0 = 6,
  NVML_NVLINK_VERSION_5_0 = 7
};
typedef enum nvmlNvlinkVersion_t nvmlNvlinkVersion_t;

/* "cy_nvml.pxd":239
 *     NVML_NVLINK_VERSION_5_0 "NVML_NVLINK_VERSION_5_0" = 7
 * 
 * ctypedef enum nvmlEccCounterType_t "nvmlEccCounterType_t":             # <<<<<<<<<<<<<<
 *     NVML_VOLATILE_ECC "NVML_VOLATILE_ECC" = 0
 *     NVML_AGGREGATE_ECC "NVML_AGGREGATE_ECC" = 1
*/
enum nvmlEccCounterType_t {
  NVML_VOLATILE_ECC = 0,
  NVML_AGGREGATE_ECC = 1,
  NVML_ECC_COUNTER_TYPE_COUNT
};
typedef enum nvmlEccCounterType_t nvmlEccCounterType_t;

/* "cy_nvml.pxd":244
 *     NVML_ECC_COUNTER_TYPE_COUNT "NVML_ECC_COUNTER_TYPE_COUNT"
 * 
 * ctypedef enum nvmlClockType_t "nvmlClockType_t":             # <<<<<<<<<<<<<<
 *     NVML_CLOCK_GRAPHICS "NVML_CLOCK_GRAPHICS" = 0
 *     NVML_CLOCK_SM "NVML_CLOCK_SM" = 1
*/
enum nvmlClockType_t {
  NVML_CLOCK_GRAPHICS = 0,
  NVML_CLOCK_SM = 1,
  NVML_CLOCK_MEM = 2,
  NVML_CLOCK_VIDEO = 3,
  NVML_CLOCK_COUNT
};
typedef enum nvmlClockType_t nvmlClockType_t;

/* "cy_nvml.pxd":251
 *     NVML_CLOCK_COUNT "NVML_CLOCK_COUNT"
 * 
 * ctypedef enum nvmlClockId_t "nvmlClockId_t":             # <<<<<<<<<<<<<<
 *     NVML_CLOCK_ID_CURRENT "NVML_CLOCK_ID_CURRENT" = 0
 *     NVML_CLOCK_ID_APP_CLOCK_TARGET "NVML_CLOCK_ID_APP_CLOCK_TARGET" = 1
*/
enum nvmlClockId_t {
  NVML_CLOCK_ID_CURRENT = 0,
  NVML_CLOCK_ID_APP_CLOCK_TARGET = 1,
  NVML_CLOCK_ID_APP_CLOCK_DEFAULT = 2,
  NVML_CLOCK_ID_CUSTOMER_BOOST_MAX = 3,
  NVML_CLOCK_ID_COUNT
};
typedef enum nvmlClockId_t nvmlClockId_t;

/* "cy_nvml.pxd":258
 *     NVML_CLOCK_ID_COUNT "NVML_CLOCK_ID_COUNT"
 * 
 * ctypedef enum nvmlDriverModel_t "nvmlDriverModel_t":             # <<<<<<<<<<<<<<
 *     NVML_DRIVER_WDDM "NVML_DRIVER_WDDM" = 0
 *     NVML_DRIVER_WDM "NVML_DRIVER_WDM" = 1
*/
enum nvmlDriverModel_t {
  NVML_DRIVER_WDDM = 0,
  NVML_DRIVER_WDM = 1,
  NVML_DRIVER_MCDM = 2
};
typedef enum nvmlDriverModel_t nvmlDriverModel_t;

/* "cy_nvml.pxd":263
 *     NVML_DRIVER_MCDM "NVML_DRIVER_MCDM" = 2
 * 
 * ctypedef enum nvmlPstates_t "nvmlPstates_t":             # <<<<<<<<<<<<<<
 *     NVML_PSTATE_0 "NVML_PSTATE_0" = 0
 *     NVML_PSTATE_1 "NVML_PSTATE_1" = 1
*/
enum nvmlPstates_t {
  NVML_PSTATE_0 = 0,
  NVML_PSTATE_1 = 1,
  NVML_PSTATE_2 = 2,
  NVML_PSTATE_3 = 3,
  NVML_PSTATE_4 = 4,
  NVML_PSTATE_5 = 5,
  NVML_PSTATE_6 = 6,
  NVML_PSTATE_7 = 7,
  NVML_PSTATE_8 = 8,
  NVML_PSTATE_9 = 9,
  NVML_PSTATE_10 = 10,
  NVML_PSTATE_11 = 11,
  NVML_PSTATE_12 = 12,
  NVML_PSTATE_13 = 13,
  NVML_PSTATE_14 = 14,
  NVML_PSTATE_15 = 15,
  NVML_PSTATE_UNKNOWN = 32
};
typedef enum nvmlPstates_t nvmlPstates_t;

/* "cy_nvml.pxd":282
 *     NVML_PSTATE_UNKNOWN "NVML_PSTATE_UNKNOWN" = 32
 * 
 * ctypedef enum nvmlGpuOperationMode_t "nvmlGpuOperationMode_t":             # <<<<<<<<<<<<<<
 *     NVML_GOM_ALL_ON "NVML_GOM_ALL_ON" = 0
 *     NVML_GOM_COMPUTE "NVML_GOM_COMPUTE" = 1
*/
enum nvmlGpuOperationMode_t {
  NVML_GOM_ALL_ON = 0,
  NVML_GOM_COMPUTE = 1,
  NVML_GOM_LOW_DP = 2
};
typedef enum nvmlGpuOperationMode_t nvmlGpuOperationMode_t;

/* "cy_nvml.pxd":287
 *     NVML_GOM_LOW_DP "NVML_GOM_LOW_DP" = 2
 * 
 * ctypedef enum nvmlInforomObject_t "nvmlInforomObject_t":             # <<<<<<<<<<<<<<
 *     NVML_INFOROM_OEM "NVML_INFOROM_OEM" = 0
 *     NVML_INFOROM_ECC "NVML_INFOROM_ECC" = 1
*/
enum nvmlInforomObject_t {
  NVML_INFOROM_OEM = 0,
  NVML_INFOROM_ECC = 1,
  NVML_INFOROM_POWER = 2,
  NVML_INFOROM_DEN = 3,
  NVML_INFOROM_COUNT
};
typedef enum nvmlInforomObject_t nvmlInforomObject_t;

/* "cy_nvml.pxd":294
 *     NVML_INFOROM_COUNT "NVML_INFOROM_COUNT"
 * 
 * ctypedef enum nvmlReturn_t "nvmlReturn_t":             # <<<<<<<<<<<<<<
 *     NVML_SUCCESS "NVML_SUCCESS" = 0
 *     NVML_ERROR_UNINITIALIZED "NVML_ERROR_UNINITIALIZED" = 1
*/
enum nvmlReturn_t {
  NVML_SUCCESS = 0,
  NVML_ERROR_UNINITIALIZED = 1,
  NVML_ERROR_INVALID_ARGUMENT = 2,
  NVML_ERROR_NOT_SUPPORTED = 3,
  NVML_ERROR_NO_PERMISSION = 4,
  NVML_ERROR_ALREADY_INITIALIZED = 5,
  NVML_ERROR_NOT_FOUND = 6,
  NVML_ERROR_INSUFFICIENT_SIZE = 7,
  NVML_ERROR_INSUFFICIENT_POWER = 8,
  NVML_ERROR_DRIVER_NOT_LOADED = 9,
  NVML_ERROR_TIMEOUT = 10,
  NVML_ERROR_IRQ_ISSUE = 11,
  NVML_ERROR_LIBRARY_NOT_FOUND = 12,
  NVML_ERROR_FUNCTION_NOT_FOUND = 13,
  NVML_ERROR_CORRUPTED_INFOROM = 14,
  NVML_ERROR_GPU_IS_LOST = 15,
  NVML_ERROR_RESET_REQUIRED = 16,
  NVML_ERROR_OPERATING_SYSTEM = 17,
  NVML_ERROR_LIB_RM_VERSION_MISMATCH = 18,
  NVML_ERROR_IN_USE = 19,
  NVML_ERROR_MEMORY = 20,
  NVML_ERROR_NO_DATA = 21,
  NVML_ERROR_VGPU_ECC_NOT_SUPPORTED = 22,
  NVML_ERROR_INSUFFICIENT_RESOURCES = 23,
  NVML_ERROR_FREQ_NOT_SUPPORTED = 24,
  NVML_ERROR_ARGUMENT_VERSION_MISMATCH = 25,
  NVML_ERROR_DEPRECATED = 26,
  NVML_ERROR_NOT_READY = 27,
  NVML_ERROR_GPU_NOT_FOUND = 28,
  NVML_ERROR_INVALID_STATE = 29,
  NVML_ERROR_RESET_TYPE_NOT_SUPPORTED = 30,
  NVML_ERROR_UNKNOWN = 0x3E7,
  _NVMLRETURN_T_INTERNAL_LOADING_ERROR = -42L
};
typedef enum nvmlReturn_t nvmlReturn_t;

/* "cy_nvml.pxd":329
 *     _NVMLRETURN_T_INTERNAL_LOADING_ERROR "_NVMLRETURN_T_INTERNAL_LOADING_ERROR" = -42
 * 
 * ctypedef enum nvmlMemoryLocation_t "nvmlMemoryLocation_t":             # <<<<<<<<<<<<<<
 *     NVML_MEMORY_LOCATION_L1_CACHE "NVML_MEMORY_LOCATION_L1_CACHE" = 0
 *     NVML_MEMORY_LOCATION_L2_CACHE "NVML_MEMORY_LOCATION_L2_CACHE" = 1
*/
enum nvmlMemoryLocation_t {
  NVML_MEMORY_LOCATION_L1_CACHE = 0,
  NVML_MEMORY_LOCATION_L2_CACHE = 1,
  NVML_MEMORY_LOCATION_DRAM = 2,
  NVML_MEMORY_LOCATION_DEVICE_MEMORY = 2,
  NVML_MEMORY_LOCATION_REGISTER_FILE = 3,
  NVML_MEMORY_LOCATION_TEXTURE_MEMORY = 4,
  NVML_MEMORY_LOCATION_TEXTURE_SHM = 5,
  NVML_MEMORY_LOCATION_CBU = 6,
  NVML_MEMORY_LOCATION_SRAM = 7,
  NVML_MEMORY_LOCATION_COUNT
};
typedef enum nvmlMemoryLocation_t nvmlMemoryLocation_t;

/* "cy_nvml.pxd":341
 *     NVML_MEMORY_LOCATION_COUNT "NVML_MEMORY_LOCATION_COUNT"
 * 
 * ctypedef enum nvmlPageRetirementCause_t "nvmlPageRetirementCause_t":             # <<<<<<<<<<<<<<
 *     NVML_PAGE_RETIREMENT_CAUSE_MULTIPLE_SINGLE_BIT_ECC_ERRORS "NVML_PAGE_RETIREMENT_CAUSE_MULTIPLE_SINGLE_BIT_ECC_ERRORS" = 0
 *     NVML_PAGE_RETIREMENT_CAUSE_DOUBLE_BIT_ECC_ERROR "NVML_PAGE_RETIREMENT_CAUSE_DOUBLE_BIT_ECC_ERROR" = 1
*/
enum nvmlPageRetirementCause_t {
  NVML_PAGE_RETIREMENT_CAUSE_MULTIPLE_SINGLE_BIT_ECC_ERRORS = 0,
  NVML_PAGE_RETIREMENT_CAUSE_DOUBLE_BIT_ECC_ERROR = 1,
  NVML_PAGE_RETIREMENT_CAUSE_COUNT
};
typedef enum nvmlPageRetirementCause_t nvmlPageRetirementCause_t;

/* "cy_nvml.pxd":346
 *     NVML_PAGE_RETIREMENT_CAUSE_COUNT "NVML_PAGE_RETIREMENT_CAUSE_COUNT"
 * 
 * ctypedef enum nvmlRestrictedAPI_t "nvmlRestrictedAPI_t":             # <<<<<<<<<<<<<<
 *     NVML_RESTRICTED_API_SET_APPLICATION_CLOCKS "NVML_RESTRICTED_API_SET_APPLICATION_CLOCKS" = 0
 *     NVML_RESTRICTED_API_SET_AUTO_BOOSTED_CLOCKS "NVML_RESTRICTED_API_SET_AUTO_BOOSTED_CLOCKS" = 1
*/
enum nvmlRestrictedAPI_t {
  NVML_RESTRICTED_API_SET_APPLICATION_CLOCKS = 0,
  NVML_RESTRICTED_API_SET_AUTO_BOOSTED_CLOCKS = 1,
  NVML_RESTRICTED_API_COUNT
};
typedef enum nvmlRestrictedAPI_t nvmlRestrictedAPI_t;

/* "cy_nvml.pxd":351
 *     NVML_RESTRICTED_API_COUNT "NVML_RESTRICTED_API_COUNT"
 * 
 * ctypedef enum nvmlGpuUtilizationDomainId_t "nvmlGpuUtilizationDomainId_t":             # <<<<<<<<<<<<<<
 *     NVML_GPU_UTILIZATION_DOMAIN_GPU "NVML_GPU_UTILIZATION_DOMAIN_GPU" = 0
 *     NVML_GPU_UTILIZATION_DOMAIN_FB "NVML_GPU_UTILIZATION_DOMAIN_FB" = 1
*/
enum nvmlGpuUtilizationDomainId_t {
  NVML_GPU_UTILIZATION_DOMAIN_GPU = 0,
  NVML_GPU_UTILIZATION_DOMAIN_FB = 1,
  NVML_GPU_UTILIZATION_DOMAIN_VID = 2,
  NVML_GPU_UTILIZATION_DOMAIN_BUS = 3
};
typedef enum nvmlGpuUtilizationDomainId_t nvmlGpuUtilizationDomainId_t;

/* "cy_nvml.pxd":357
 *     NVML_GPU_UTILIZATION_DOMAIN_BUS "NVML_GPU_UTILIZATION_DOMAIN_BUS" = 3
 * 
 * ctypedef enum nvmlGpuVirtualizationMode_t "nvmlGpuVirtualizationMode_t":             # <<<<<<<<<<<<<<
 *     NVML_GPU_VIRTUALIZATION_MODE_NONE "NVML_GPU_VIRTUALIZATION_MODE_NONE" = 0
 *     NVML_GPU_VIRTUALIZATION_MODE_PASSTHROUGH "NVML_GPU_VIRTUALIZATION_MODE_PASSTHROUGH" = 1
*/
enum nvmlGpuVirtualizationMode_t {
  NVML_GPU_VIRTUALIZATION_MODE_NONE = 0,
  NVML_GPU_VIRTUALIZATION_MODE_PASSTHROUGH = 1,
  NVML_GPU_VIRTUALIZATION_MODE_VGPU = 2,
  NVML_GPU_VIRTUALIZATION_MODE_HOST_VGPU = 3,
  NVML_GPU_VIRTUALIZATION_MODE_HOST_VSGA = 4
};
typedef enum nvmlGpuVirtualizationMode_t nvmlGpuVirtualizationMode_t;

/* "cy_nvml.pxd":364
 *     NVML_GPU_VIRTUALIZATION_MODE_HOST_VSGA "NVML_GPU_VIRTUALIZATION_MODE_HOST_VSGA" = 4
 * 
 * ctypedef enum nvmlHostVgpuMode_t "nvmlHostVgpuMode_t":             # <<<<<<<<<<<<<<
 *     NVML_HOST_VGPU_MODE_NON_SRIOV "NVML_HOST_VGPU_MODE_NON_SRIOV" = 0
 *     NVML_HOST_VGPU_MODE_SRIOV "NVML_HOST_VGPU_MODE_SRIOV" = 1
*/
enum nvmlHostVgpuMode_t {
  NVML_HOST_VGPU_MODE_NON_SRIOV = 0,
  NVML_HOST_VGPU_MODE_SRIOV = 1
};
typedef enum nvmlHostVgpuMode_t nvmlHostVgpuMode_t;

/* "cy_nvml.pxd":368
 *     NVML_HOST_VGPU_MODE_SRIOV "NVML_HOST_VGPU_MODE_SRIOV" = 1
 * 
 * ctypedef enum nvmlVgpuVmIdType_t "nvmlVgpuVmIdType_t":             # <<<<<<<<<<<<<<
 *     NVML_VGPU_VM_ID_DOMAIN_ID "NVML_VGPU_VM_ID_DOMAIN_ID" = 0
 *     NVML_VGPU_VM_ID_UUID "NVML_VGPU_VM_ID_UUID" = 1
*/
enum nvmlVgpuVmIdType_t {
  NVML_VGPU_VM_ID_DOMAIN_ID = 0,
  NVML_VGPU_VM_ID_UUID = 1
};
typedef enum nvmlVgpuVmIdType_t nvmlVgpuVmIdType_t;

/* "cy_nvml.pxd":372
 *     NVML_VGPU_VM_ID_UUID "NVML_VGPU_VM_ID_UUID" = 1
 * 
 * ctypedef enum nvmlVgpuGuestInfoState_t "nvmlVgpuGuestInfoState_t":             # <<<<<<<<<<<<<<
 *     NVML_VGPU_INSTANCE_GUEST_INFO_STATE_UNINITIALIZED "NVML_VGPU_INSTANCE_GUEST_INFO_STATE_UNINITIALIZED" = 0
 *     NVML_VGPU_INSTANCE_GUEST_INFO_STATE_INITIALIZED "NVML_VGPU_INSTANCE_GUEST_INFO_STATE_INITIALIZED" = 1
*/
enum nvmlVgpuGuestInfoState_t {
  NVML_VGPU_INSTANCE_GUEST_INFO_STATE_UNINITIALIZED = 0,
  NVML_VGPU_INSTANCE_GUEST_INFO_STATE_INITIALIZED = 1
};
typedef enum nvmlVgpuGuestInfoState_t nvmlVgpuGuestInfoState_t;

/* "cy_nvml.pxd":376
 *     NVML_VGPU_INSTANCE_GUEST_INFO_STATE_INITIALIZED "NVML_VGPU_INSTANCE_GUEST_INFO_STATE_INITIALIZED" = 1
 * 
 * ctypedef enum nvmlGridLicenseFeatureCode_t "nvmlGridLicenseFeatureCode_t":             # <<<<<<<<<<<<<<
 *     NVML_GRID_LICENSE_FEATURE_CODE_UNKNOWN "NVML_GRID_LICENSE_FEATURE_CODE_UNKNOWN" = 0
 *     NVML_GRID_LICENSE_FEATURE_CODE_VGPU "NVML_GRID_LICENSE_FEATURE_CODE_VGPU" = 1
*/
enum nvmlGridLicenseFeatureCode_t {

  /* "cy_nvml.pxd":380
 *     NVML_GRID_LICENSE_FEATURE_CODE_VGPU "NVML_GRID_LICENSE_FEATURE_CODE_VGPU" = 1
 *     NVML_GRID_LICENSE_FEATURE_CODE_NVIDIA_RTX "NVML_GRID_LICENSE_FEATURE_CODE_NVIDIA_RTX" = 2
 *     NVML_GRID_LICENSE_FEATURE_CODE_VWORKSTATION "NVML_GRID_LICENSE_FEATURE_CODE_VWORKSTATION" = NVML_GRID_LICENSE_FEATURE_CODE_NVIDIA_RTX             # <<<<<<<<<<<<<<
 *     NVML_GRID_LICENSE_FEATURE_CODE_GAMING "NVML_GRID_LICENSE_FEATURE_CODE_GAMING" = 3
 *     NVML_GRID_LICENSE_FEATURE_CODE_COMPUTE "NVML_GRID_LICENSE_FEATURE_CODE_COMPUTE" = 4
*/
  NVML_GRID_LICENSE_FEATURE_CODE_UNKNOWN = 0,
  NVML_GRID_LICENSE_FEATURE_CODE_VGPU = 1,
  NVML_GRID_LICENSE_FEATURE_CODE_NVIDIA_RTX = 2,
  NVML_GRID_LICENSE_FEATURE_CODE_VWORKSTATION = NVML_GRID_LICENSE_FEATURE_CODE_NVIDIA_RTX,
  NVML_GRID_LICENSE_FEATURE_CODE_GAMING = 3,
  NVML_GRID_LICENSE_FEATURE_CODE_COMPUTE = 4
};
typedef enum nvmlGridLicenseFeatureCode_t nvmlGridLicenseFeatureCode_t;

/* "cy_nvml.pxd":384
 *     NVML_GRID_LICENSE_FEATURE_CODE_COMPUTE "NVML_GRID_LICENSE_FEATURE_CODE_COMPUTE" = 4
 * 
 * ctypedef enum nvmlVgpuCapability_t "nvmlVgpuCapability_t":             # <<<<<<<<<<<<<<
 *     NVML_VGPU_CAP_NVLINK_P2P "NVML_VGPU_CAP_NVLINK_P2P" = 0
 *     NVML_VGPU_CAP_GPUDIRECT "NVML_VGPU_CAP_GPUDIRECT" = 1
*/
enum nvmlVgpuCapability_t {
  NVML_VGPU_CAP_NVLINK_P2P = 0,
  NVML_VGPU_CAP_GPUDIRECT = 1,
  NVML_VGPU_CAP_MULTI_VGPU_EXCLUSIVE = 2,
  NVML_VGPU_CAP_EXCLUSIVE_TYPE = 3,
  NVML_VGPU_CAP_EXCLUSIVE_SIZE = 4,
  NVML_VGPU_CAP_COUNT
};
typedef enum nvmlVgpuCapability_t nvmlVgpuCapability_t;

/* "cy_nvml.pxd":392
 *     NVML_VGPU_CAP_COUNT "NVML_VGPU_CAP_COUNT"
 * 
 * ctypedef enum nvmlVgpuDriverCapability_t "nvmlVgpuDriverCapability_t":             # <<<<<<<<<<<<<<
 *     NVML_VGPU_DRIVER_CAP_HETEROGENEOUS_MULTI_VGPU "NVML_VGPU_DRIVER_CAP_HETEROGENEOUS_MULTI_VGPU" = 0
 *     NVML_VGPU_DRIVER_CAP_WARM_UPDATE "NVML_VGPU_DRIVER_CAP_WARM_UPDATE" = 1
*/
enum nvmlVgpuDriverCapability_t {
  NVML_VGPU_DRIVER_CAP_HETEROGENEOUS_MULTI_VGPU = 0,
  NVML_VGPU_DRIVER_CAP_WARM_UPDATE = 1,
  NVML_VGPU_DRIVER_CAP_COUNT
};
typedef enum nvmlVgpuDriverCapability_t nvmlVgpuDriverCapability_t;

/* "cy_nvml.pxd":397
 *     NVML_VGPU_DRIVER_CAP_COUNT "NVML_VGPU_DRIVER_CAP_COUNT"
 * 
 * ctypedef enum nvmlDeviceVgpuCapability_t "nvmlDeviceVgpuCapability_t":             # <<<<<<<<<<<<<<
 *     NVML_DEVICE_VGPU_CAP_FRACTIONAL_MULTI_VGPU "NVML_DEVICE_VGPU_CAP_FRACTIONAL_MULTI_VGPU" = 0
 *     NVML_DEVICE_VGPU_CAP_HETEROGENEOUS_TIMESLICE_PROFILES "NVML_DEVICE_VGPU_CAP_HETEROGENEOUS_TIMESLICE_PROFILES" = 1
*/
enum nvmlDeviceVgpuCapability_t {
  NVML_DEVICE_VGPU_CAP_FRACTIONAL_MULTI_VGPU = 0,
  NVML_DEVICE_VGPU_CAP_HETEROGENEOUS_TIMESLICE_PROFILES = 1,
  NVML_DEVICE_VGPU_CAP_HETEROGENEOUS_TIMESLICE_SIZES = 2,
  NVML_DEVICE_VGPU_CAP_READ_DEVICE_BUFFER_BW = 3,
  NVML_DEVICE_VGPU_CAP_WRITE_DEVICE_BUFFER_BW = 4,
  NVML_DEVICE_VGPU_CAP_DEVICE_STREAMING = 5,
  NVML_DEVICE_VGPU_CAP_MINI_QUARTER_GPU = 6,
  NVML_DEVICE_VGPU_CAP_COMPUTE_MEDIA_ENGINE_GPU = 7,
  NVML_DEVICE_VGPU_CAP_WARM_UPDATE = 8,
  NVML_DEVICE_VGPU_CAP_HOMOGENEOUS_PLACEMENTS = 9,
  NVML_DEVICE_VGPU_CAP_MIG_TIMESLICING_SUPPORTED = 10,
  NVML_DEVICE_VGPU_CAP_MIG_TIMESLICING_ENABLED = 11,
  NVML_DEVICE_VGPU_CAP_COUNT
};
typedef enum nvmlDeviceVgpuCapability_t nvmlDeviceVgpuCapability_t;

/* "cy_nvml.pxd":412
 *     NVML_DEVICE_VGPU_CAP_COUNT "NVML_DEVICE_VGPU_CAP_COUNT"
 * 
 * ctypedef enum nvmlDeviceGpuRecoveryAction_t "nvmlDeviceGpuRecoveryAction_t":             # <<<<<<<<<<<<<<
 *     NVML_GPU_RECOVERY_ACTION_NONE "NVML_GPU_RECOVERY_ACTION_NONE" = 0
 *     NVML_GPU_RECOVERY_ACTION_GPU_RESET "NVML_GPU_RECOVERY_ACTION_GPU_RESET" = 1
*/
enum nvmlDeviceGpuRecoveryAction_t {
  NVML_GPU_RECOVERY_ACTION_NONE = 0,
  NVML_GPU_RECOVERY_ACTION_GPU_RESET = 1,
  NVML_GPU_RECOVERY_ACTION_NODE_REBOOT = 2,
  NVML_GPU_RECOVERY_ACTION_DRAIN_P2P = 3,
  NVML_GPU_RECOVERY_ACTION_DRAIN_AND_RESET = 4
};
typedef enum nvmlDeviceGpuRecoveryAction_t nvmlDeviceGpuRecoveryAction_t;

/* "cy_nvml.pxd":419
 *     NVML_GPU_RECOVERY_ACTION_DRAIN_AND_RESET "NVML_GPU_RECOVERY_ACTION_DRAIN_AND_RESET" = 4
 * 
 * ctypedef enum nvmlFanState_t "nvmlFanState_t":             # <<<<<<<<<<<<<<
 *     NVML_FAN_NORMAL "NVML_FAN_NORMAL" = 0
 *     NVML_FAN_FAILED "NVML_FAN_FAILED" = 1
*/
enum nvmlFanState_t {
  NVML_FAN_NORMAL = 0,
  NVML_FAN_FAILED = 1
};
typedef enum nvmlFanState_t nvmlFanState_t;

/* "cy_nvml.pxd":423
 *     NVML_FAN_FAILED "NVML_FAN_FAILED" = 1
 * 
 * ctypedef enum nvmlLedColor_t "nvmlLedColor_t":             # <<<<<<<<<<<<<<
 *     NVML_LED_COLOR_GREEN "NVML_LED_COLOR_GREEN" = 0
 *     NVML_LED_COLOR_AMBER "NVML_LED_COLOR_AMBER" = 1
*/
enum nvmlLedColor_t {
  NVML_LED_COLOR_GREEN = 0,
  NVML_LED_COLOR_AMBER = 1
};
typedef enum nvmlLedColor_t nvmlLedColor_t;

/* "cy_nvml.pxd":427
 *     NVML_LED_COLOR_AMBER "NVML_LED_COLOR_AMBER" = 1
 * 
 * ctypedef enum nvmlEncoderType_t "nvmlEncoderType_t":             # <<<<<<<<<<<<<<
 *     NVML_ENCODER_QUERY_H264 "NVML_ENCODER_QUERY_H264" = 0x00
 *     NVML_ENCODER_QUERY_HEVC "NVML_ENCODER_QUERY_HEVC" = 0x01
*/
enum nvmlEncoderType_t {
  NVML_ENCODER_QUERY_H264 = 0x00,
  NVML_ENCODER_QUERY_HEVC = 0x01,
  NVML_ENCODER_QUERY_AV1 = 0x02,
  NVML_ENCODER_QUERY_UNKNOWN = 0xFF
};
typedef enum nvmlEncoderType_t nvmlEncoderType_t;

/* "cy_nvml.pxd":433
 *     NVML_ENCODER_QUERY_UNKNOWN "NVML_ENCODER_QUERY_UNKNOWN" = 0xFF
 * 
 * ctypedef enum nvmlFBCSessionType_t "nvmlFBCSessionType_t":             # <<<<<<<<<<<<<<
 *     NVML_FBC_SESSION_TYPE_UNKNOWN "NVML_FBC_SESSION_TYPE_UNKNOWN" = 0
 *     NVML_FBC_SESSION_TYPE_TOSYS "NVML_FBC_SESSION_TYPE_TOSYS"
*/
enum nvmlFBCSessionType_t {
  NVML_FBC_SESSION_TYPE_UNKNOWN = 0,
  NVML_FBC_SESSION_TYPE_TOSYS,
  NVML_FBC_SESSION_TYPE_CUDA,
  NVML_FBC_SESSION_TYPE_VID,
  NVML_FBC_SESSION_TYPE_HWENC
};
typedef enum nvmlFBCSessionType_t nvmlFBCSessionType_t;

/* "cy_nvml.pxd":440
 *     NVML_FBC_SESSION_TYPE_HWENC "NVML_FBC_SESSION_TYPE_HWENC"
 * 
 * ctypedef enum nvmlDetachGpuState_t "nvmlDetachGpuState_t":             # <<<<<<<<<<<<<<
 *     NVML_DETACH_GPU_KEEP "NVML_DETACH_GPU_KEEP" = 0
 *     NVML_DETACH_GPU_REMOVE "NVML_DETACH_GPU_REMOVE"
*/
enum nvmlDetachGpuState_t {
  NVML_DETACH_GPU_KEEP = 0,
  NVML_DETACH_GPU_REMOVE
};
typedef enum nvmlDetachGpuState_t nvmlDetachGpuState_t;

/* "cy_nvml.pxd":444
 *     NVML_DETACH_GPU_REMOVE "NVML_DETACH_GPU_REMOVE"
 * 
 * ctypedef enum nvmlPcieLinkState_t "nvmlPcieLinkState_t":             # <<<<<<<<<<<<<<
 *     NVML_PCIE_LINK_KEEP "NVML_PCIE_LINK_KEEP" = 0
 *     NVML_PCIE_LINK_SHUT_DOWN "NVML_PCIE_LINK_SHUT_DOWN"
*/
enum nvmlPcieLinkState_t {
  NVML_PCIE_LINK_KEEP = 0,
  NVML_PCIE_LINK_SHUT_DOWN
};
typedef enum nvmlPcieLinkState_t nvmlPcieLinkState_t;

/* "cy_nvml.pxd":448
 *     NVML_PCIE_LINK_SHUT_DOWN "NVML_PCIE_LINK_SHUT_DOWN"
 * 
 * ctypedef enum nvmlClockLimitId_t "nvmlClockLimitId_t":             # <<<<<<<<<<<<<<
 *     NVML_CLOCK_LIMIT_ID_RANGE_START "NVML_CLOCK_LIMIT_ID_RANGE_START" = 0xffffff00
 *     NVML_CLOCK_LIMIT_ID_TDP "NVML_CLOCK_LIMIT_ID_TDP"
*/
enum nvmlClockLimitId_t {
  NVML_CLOCK_LIMIT_ID_RANGE_START = 0xffffff00,
  NVML_CLOCK_LIMIT_ID_TDP,
  NVML_CLOCK_LIMIT_ID_UNLIMITED
};
typedef enum nvmlClockLimitId_t nvmlClockLimitId_t;

/* "cy_nvml.pxd":453
 *     NVML_CLOCK_LIMIT_ID_UNLIMITED "NVML_CLOCK_LIMIT_ID_UNLIMITED"
 * 
 * ctypedef enum nvmlVgpuVmCompatibility_t "nvmlVgpuVmCompatibility_t":             # <<<<<<<<<<<<<<
 *     NVML_VGPU_VM_COMPATIBILITY_NONE "NVML_VGPU_VM_COMPATIBILITY_NONE" = 0x0
 *     NVML_VGPU_VM_COMPATIBILITY_COLD "NVML_VGPU_VM_COMPATIBILITY_COLD" = 0x1
*/
enum nvmlVgpuVmCompatibility_t {
  NVML_VGPU_VM_COMPATIBILITY_NONE = 0x0,
  NVML_VGPU_VM_COMPATIBILITY_COLD = 0x1,
  NVML_VGPU_VM_COMPATIBILITY_HIBERNATE = 0x2,
  NVML_VGPU_VM_COMPATIBILITY_SLEEP = 0x4,
  NVML_VGPU_VM_COMPATIBILITY_LIVE = 0x8
};
typedef enum nvmlVgpuVmCompatibility_t nvmlVgpuVmCompatibility_t;

/* "cy_nvml.pxd":460
 *     NVML_VGPU_VM_COMPATIBILITY_LIVE "NVML_VGPU_VM_COMPATIBILITY_LIVE" = 0x8
 * 
 * ctypedef enum nvmlVgpuPgpuCompatibilityLimitCode_t "nvmlVgpuPgpuCompatibilityLimitCode_t":             # <<<<<<<<<<<<<<
 *     NVML_VGPU_COMPATIBILITY_LIMIT_NONE "NVML_VGPU_COMPATIBILITY_LIMIT_NONE" = 0x0
 *     NVML_VGPU_COMPATIBILITY_LIMIT_HOST_DRIVER "NVML_VGPU_COMPATIBILITY_LIMIT_HOST_DRIVER" = 0x1
*/
enum nvmlVgpuPgpuCompatibilityLimitCode_t {
  NVML_VGPU_COMPATIBILITY_LIMIT_NONE = 0x0,
  NVML_VGPU_COMPATIBILITY_LIMIT_HOST_DRIVER = 0x1,
  NVML_VGPU_COMPATIBILITY_LIMIT_GUEST_DRIVER = 0x2,
  NVML_VGPU_COMPATIBILITY_LIMIT_GPU = 0x4,
  NVML_VGPU_COMPATIBILITY_LIMIT_OTHER = 0x80000000
};
typedef enum nvmlVgpuPgpuCompatibilityLimitCode_t nvmlVgpuPgpuCompatibilityLimitCode_t;

/* "cy_nvml.pxd":467
 *     NVML_VGPU_COMPATIBILITY_LIMIT_OTHER "NVML_VGPU_COMPATIBILITY_LIMIT_OTHER" = 0x80000000
 * 
 * ctypedef enum nvmlGpmMetricId_t "nvmlGpmMetricId_t":             # <<<<<<<<<<<<<<
 *     NVML_GPM_METRIC_GRAPHICS_UTIL "NVML_GPM_METRIC_GRAPHICS_UTIL" = 1
 *     NVML_GPM_METRIC_SM_UTIL "NVML_GPM_METRIC_SM_UTIL" = 2
*/
enum nvmlGpmMetricId_t {
  NVML_GPM_METRIC_GRAPHICS_UTIL = 1,
  NVML_GPM_METRIC_SM_UTIL = 2,
  NVML_GPM_METRIC_SM_OCCUPANCY = 3,
  NVML_GPM_METRIC_INTEGER_UTIL = 4,
  NVML_GPM_METRIC_ANY_TENSOR_UTIL = 5,
  NVML_GPM_METRIC_DFMA_TENSOR_UTIL = 6,
  NVML_GPM_METRIC_HMMA_TENSOR_UTIL = 7,
  NVML_GPM_METRIC_IMMA_TENSOR_UTIL = 9,
  NVML_GPM_METRIC_DRAM_BW_UTIL = 10,
  NVML_GPM_METRIC_FP64_UTIL = 11,
  NVML_GPM_METRIC_FP32_UTIL = 12,
  NVML_GPM_METRIC_FP16_UTIL = 13,
  NVML_GPM_METRIC_PCIE_TX_PER_SEC = 20,
  NVML_GPM_METRIC_PCIE_RX_PER_SEC = 21,
  NVML_GPM_METRIC_NVDEC_0_UTIL = 30,
  NVML_GPM_METRIC_NVDEC_1_UTIL = 31,
  NVML_GPM_METRIC_NVDEC_2_UTIL = 32,
  NVML_GPM_METRIC_NVDEC_3_UTIL = 33,
  NVML_GPM_METRIC_NVDEC_4_UTIL = 34,
  NVML_GPM_METRIC_NVDEC_5_UTIL = 35,
  NVML_GPM_METRIC_NVDEC_6_UTIL = 36,
  NVML_GPM_METRIC_NVDEC_7_UTIL = 37,
  NVML_GPM_METRIC_NVJPG_0_UTIL = 40,
  NVML_GPM_METRIC_NVJPG_1_UTIL = 41,
  NVML_GPM_METRIC_NVJPG_2_UTIL = 42,
  NVML_GPM_METRIC_NVJPG_3_UTIL = 43,
  NVML_GPM_METRIC_NVJPG_4_UTIL = 44,
  NVML_GPM_METRIC_NVJPG_5_UTIL = 45,
  NVML_GPM_METRIC_NVJPG_6_UTIL = 46,
  NVML_GPM_METRIC_NVJPG_7_UTIL = 47,
  NVML_GPM_METRIC_NVOFA_0_UTIL = 50,
  NVML_GPM_METRIC_NVOFA_1_UTIL = 51,
  NVML_GPM_METRIC_NVLINK_TOTAL_RX_PER_SEC = 60,
  NVML_GPM_METRIC_NVLINK_TOTAL_TX_PER_SEC = 61,
  NVML_GPM_METRIC_NVLINK_L0_RX_PER_SEC = 62,
  NVML_GPM_METRIC_NVLINK_L0_TX_PER_SEC = 63,
  NVML_GPM_METRIC_NVLINK_L1_RX_PER_SEC = 64,
  NVML_GPM_METRIC_NVLINK_L1_TX_PER_SEC = 65,
  NVML_GPM_METRIC_NVLINK_L2_RX_PER_SEC = 66,
  NVML_GPM_METRIC_NVLINK_L2_TX_PER_SEC = 67,
  NVML_GPM_METRIC_NVLINK_L3_RX_PER_SEC = 68,
  NVML_GPM_METRIC_NVLINK_L3_TX_PER_SEC = 69,
  NVML_GPM_METRIC_NVLINK_L4_RX_PER_SEC = 70,
  NVML_GPM_METRIC_NVLINK_L4_TX_PER_SEC = 71,
  NVML_GPM_METRIC_NVLINK_L5_RX_PER_SEC = 72,
  NVML_GPM_METRIC_NVLINK_L5_TX_PER_SEC = 73,
  NVML_GPM_METRIC_NVLINK_L6_RX_PER_SEC = 74,
  NVML_GPM_METRIC_NVLINK_L6_TX_PER_SEC = 75,
  NVML_GPM_METRIC_NVLINK_L7_RX_PER_SEC = 76,
  NVML_GPM_METRIC_NVLINK_L7_TX_PER_SEC = 77,
  NVML_GPM_METRIC_NVLINK_L8_RX_PER_SEC = 78,
  NVML_GPM_METRIC_NVLINK_L8_TX_PER_SEC = 79,
  NVML_GPM_METRIC_NVLINK_L9_RX_PER_SEC = 80,
  NVML_GPM_METRIC_NVLINK_L9_TX_PER_SEC = 81,
  NVML_GPM_METRIC_NVLINK_L10_RX_PER_SEC = 82,
  NVML_GPM_METRIC_NVLINK_L10_TX_PER_SEC = 83,
  NVML_GPM_METRIC_NVLINK_L11_RX_PER_SEC = 84,
  NVML_GPM_METRIC_NVLINK_L11_TX_PER_SEC = 85,
  NVML_GPM_METRIC_NVLINK_L12_RX_PER_SEC = 86,
  NVML_GPM_METRIC_NVLINK_L12_TX_PER_SEC = 87,
  NVML_GPM_METRIC_NVLINK_L13_RX_PER_SEC = 88,
  NVML_GPM_METRIC_NVLINK_L13_TX_PER_SEC = 89,
  NVML_GPM_METRIC_NVLINK_L14_RX_PER_SEC = 90,
  NVML_GPM_METRIC_NVLINK_L14_TX_PER_SEC = 91,
  NVML_GPM_METRIC_NVLINK_L15_RX_PER_SEC = 92,
  NVML_GPM_METRIC_NVLINK_L15_TX_PER_SEC = 93,
  NVML_GPM_METRIC_NVLINK_L16_RX_PER_SEC = 94,
  NVML_GPM_METRIC_NVLINK_L16_TX_PER_SEC = 95,
  NVML_GPM_METRIC_NVLINK_L17_RX_PER_SEC = 96,
  NVML_GPM_METRIC_NVLINK_L17_TX_PER_SEC = 97,
  NVML_GPM_METRIC_C2C_TOTAL_TX_PER_SEC = 0x64,
  NVML_GPM_METRIC_C2C_TOTAL_RX_PER_SEC = 0x65,
  NVML_GPM_METRIC_C2C_DATA_TX_PER_SEC = 0x66,
  NVML_GPM_METRIC_C2C_DATA_RX_PER_SEC = 0x67,
  NVML_GPM_METRIC_C2C_LINK0_TOTAL_TX_PER_SEC = 0x68,
  NVML_GPM_METRIC_C2C_LINK0_TOTAL_RX_PER_SEC = 0x69,
  NVML_GPM_METRIC_C2C_LINK0_DATA_TX_PER_SEC = 0x6A,
  NVML_GPM_METRIC_C2C_LINK0_DATA_RX_PER_SEC = 0x6B,
  NVML_GPM_METRIC_C2C_LINK1_TOTAL_TX_PER_SEC = 0x6C,
  NVML_GPM_METRIC_C2C_LINK1_TOTAL_RX_PER_SEC = 0x6D,
  NVML_GPM_METRIC_C2C_LINK1_DATA_TX_PER_SEC = 0x6E,
  NVML_GPM_METRIC_C2C_LINK1_DATA_RX_PER_SEC = 0x6F,
  NVML_GPM_METRIC_C2C_LINK2_TOTAL_TX_PER_SEC = 0x70,
  NVML_GPM_METRIC_C2C_LINK2_TOTAL_RX_PER_SEC = 0x71,
  NVML_GPM_METRIC_C2C_LINK2_DATA_TX_PER_SEC = 0x72,
  NVML_GPM_METRIC_C2C_LINK2_DATA_RX_PER_SEC = 0x73,
  NVML_GPM_METRIC_C2C_LINK3_TOTAL_TX_PER_SEC = 0x74,
  NVML_GPM_METRIC_C2C_LINK3_TOTAL_RX_PER_SEC = 0x75,
  NVML_GPM_METRIC_C2C_LINK3_DATA_TX_PER_SEC = 0x76,
  NVML_GPM_METRIC_C2C_LINK3_DATA_RX_PER_SEC = 0x77,
  NVML_GPM_METRIC_C2C_LINK4_TOTAL_TX_PER_SEC = 0x78,
  NVML_GPM_METRIC_C2C_LINK4_TOTAL_RX_PER_SEC = 0x79,
  NVML_GPM_METRIC_C2C_LINK4_DATA_TX_PER_SEC = 0x7A,
  NVML_GPM_METRIC_C2C_LINK4_DATA_RX_PER_SEC = 0x7B,
  NVML_GPM_METRIC_C2C_LINK5_TOTAL_TX_PER_SEC = 0x7C,
  NVML_GPM_METRIC_C2C_LINK5_TOTAL_RX_PER_SEC = 0x7D,
  NVML_GPM_METRIC_C2C_LINK5_DATA_TX_PER_SEC = 0x7E,
  NVML_GPM_METRIC_C2C_LINK5_DATA_RX_PER_SEC = 0x7F,
  NVML_GPM_METRIC_C2C_LINK6_TOTAL_TX_PER_SEC = 0x80,
  NVML_GPM_METRIC_C2C_LINK6_TOTAL_RX_PER_SEC = 0x81,
  NVML_GPM_METRIC_C2C_LINK6_DATA_TX_PER_SEC = 0x82,
  NVML_GPM_METRIC_C2C_LINK6_DATA_RX_PER_SEC = 0x83,
  NVML_GPM_METRIC_C2C_LINK7_TOTAL_TX_PER_SEC = 0x84,
  NVML_GPM_METRIC_C2C_LINK7_TOTAL_RX_PER_SEC = 0x85,
  NVML_GPM_METRIC_C2C_LINK7_DATA_TX_PER_SEC = 0x86,
  NVML_GPM_METRIC_C2C_LINK7_DATA_RX_PER_SEC = 0x87,
  NVML_GPM_METRIC_C2C_LINK8_TOTAL_TX_PER_SEC = 0x88,
  NVML_GPM_METRIC_C2C_LINK8_TOTAL_RX_PER_SEC = 0x89,
  NVML_GPM_METRIC_C2C_LINK8_DATA_TX_PER_SEC = 0x8A,
  NVML_GPM_METRIC_C2C_LINK8_DATA_RX_PER_SEC = 0x8B,
  NVML_GPM_METRIC_C2C_LINK9_TOTAL_TX_PER_SEC = 0x8C,
  NVML_GPM_METRIC_C2C_LINK9_TOTAL_RX_PER_SEC = 0x8D,
  NVML_GPM_METRIC_C2C_LINK9_DATA_TX_PER_SEC = 0x8E,
  NVML_GPM_METRIC_C2C_LINK9_DATA_RX_PER_SEC = 0x8F,
  NVML_GPM_METRIC_C2C_LINK10_TOTAL_TX_PER_SEC = 0x90,
  NVML_GPM_METRIC_C2C_LINK10_TOTAL_RX_PER_SEC = 0x91,
  NVML_GPM_METRIC_C2C_LINK10_DATA_TX_PER_SEC = 0x92,
  NVML_GPM_METRIC_C2C_LINK10_DATA_RX_PER_SEC = 0x93,
  NVML_GPM_METRIC_C2C_LINK11_TOTAL_TX_PER_SEC = 0x94,
  NVML_GPM_METRIC_C2C_LINK11_TOTAL_RX_PER_SEC = 0x95,
  NVML_GPM_METRIC_C2C_LINK11_DATA_TX_PER_SEC = 0x96,
  NVML_GPM_METRIC_C2C_LINK11_DATA_RX_PER_SEC = 0x97,
  NVML_GPM_METRIC_C2C_LINK12_TOTAL_TX_PER_SEC = 0x98,
  NVML_GPM_METRIC_C2C_LINK12_TOTAL_RX_PER_SEC = 0x99,
  NVML_GPM_METRIC_C2C_LINK12_DATA_TX_PER_SEC = 0x9A,
  NVML_GPM_METRIC_C2C_LINK12_DATA_RX_PER_SEC = 0x9B,
  NVML_GPM_METRIC_C2C_LINK13_TOTAL_TX_PER_SEC = 0x9C,
  NVML_GPM_METRIC_C2C_LINK13_TOTAL_RX_PER_SEC = 0x9D,
  NVML_GPM_METRIC_C2C_LINK13_DATA_TX_PER_SEC = 0x9E,
  NVML_GPM_METRIC_C2C_LINK13_DATA_RX_PER_SEC = 0x9F,
  NVML_GPM_METRIC_HOSTMEM_CACHE_HIT = 0xA0,
  NVML_GPM_METRIC_HOSTMEM_CACHE_MISS = 0xA1,
  NVML_GPM_METRIC_PEERMEM_CACHE_HIT = 0xA2,
  NVML_GPM_METRIC_PEERMEM_CACHE_MISS = 0xA3,
  NVML_GPM_METRIC_DRAM_CACHE_HIT = 0xA4,
  NVML_GPM_METRIC_DRAM_CACHE_MISS = 0xA5,
  NVML_GPM_METRIC_NVENC_0_UTIL = 0xA6,
  NVML_GPM_METRIC_NVENC_1_UTIL = 0xA7,
  NVML_GPM_METRIC_NVENC_2_UTIL = 0xA8,
  NVML_GPM_METRIC_NVENC_3_UTIL = 0xA9,
  NVML_GPM_METRIC_GR0_CTXSW_CYCLES_ELAPSED = 0xAA,
  NVML_GPM_METRIC_GR0_CTXSW_CYCLES_ACTIVE = 0xAB,
  NVML_GPM_METRIC_GR0_CTXSW_REQUESTS = 0xAC,
  NVML_GPM_METRIC_GR0_CTXSW_CYCLES_PER_REQ = 0xAD,
  NVML_GPM_METRIC_GR0_CTXSW_ACTIVE_PCT = 0xAE,
  NVML_GPM_METRIC_GR1_CTXSW_CYCLES_ELAPSED = 0xAF,
  NVML_GPM_METRIC_GR1_CTXSW_CYCLES_ACTIVE = 0xB0,
  NVML_GPM_METRIC_GR1_CTXSW_REQUESTS = 0xB1,
  NVML_GPM_METRIC_GR1_CTXSW_CYCLES_PER_REQ = 0xB2,
  NVML_GPM_METRIC_GR1_CTXSW_ACTIVE_PCT = 0xB3,
  NVML_GPM_METRIC_GR2_CTXSW_CYCLES_ELAPSED = 0xB4,
  NVML_GPM_METRIC_GR2_CTXSW_CYCLES_ACTIVE = 0xB5,
  NVML_GPM_METRIC_GR2_CTXSW_REQUESTS = 0xB6,
  NVML_GPM_METRIC_GR2_CTXSW_CYCLES_PER_REQ = 0xB7,
  NVML_GPM_METRIC_GR2_CTXSW_ACTIVE_PCT = 0xB8,
  NVML_GPM_METRIC_GR3_CTXSW_CYCLES_ELAPSED = 0xB9,
  NVML_GPM_METRIC_GR3_CTXSW_CYCLES_ACTIVE = 0xBA,
  NVML_GPM_METRIC_GR3_CTXSW_REQUESTS = 0xBB,
  NVML_GPM_METRIC_GR3_CTXSW_CYCLES_PER_REQ = 0xBC,
  NVML_GPM_METRIC_GR3_CTXSW_ACTIVE_PCT = 0xBD,
  NVML_GPM_METRIC_GR4_CTXSW_CYCLES_ELAPSED = 0xBE,
  NVML_GPM_METRIC_GR4_CTXSW_CYCLES_ACTIVE = 0xBF,
  NVML_GPM_METRIC_GR4_CTXSW_REQUESTS = 0xC0,
  NVML_GPM_METRIC_GR4_CTXSW_CYCLES_PER_REQ = 0xC1,
  NVML_GPM_METRIC_GR4_CTXSW_ACTIVE_PCT = 0xC2,
  NVML_GPM_METRIC_GR5_CTXSW_CYCLES_ELAPSED = 0xC3,
  NVML_GPM_METRIC_GR5_CTXSW_CYCLES_ACTIVE = 0xC4,
  NVML_GPM_METRIC_GR5_CTXSW_REQUESTS = 0xC5,
  NVML_GPM_METRIC_GR5_CTXSW_CYCLES_PER_REQ = 0xC6,
  NVML_GPM_METRIC_GR5_CTXSW_ACTIVE_PCT = 0xC7,
  NVML_GPM_METRIC_GR6_CTXSW_CYCLES_ELAPSED = 0xC8,
  NVML_GPM_METRIC_GR6_CTXSW_CYCLES_ACTIVE = 0xC9,
  NVML_GPM_METRIC_GR6_CTXSW_REQUESTS = 0xCA,
  NVML_GPM_METRIC_GR6_CTXSW_CYCLES_PER_REQ = 0xCB,
  NVML_GPM_METRIC_GR6_CTXSW_ACTIVE_PCT = 0xCC,
  NVML_GPM_METRIC_GR7_CTXSW_CYCLES_ELAPSED = 0xCD,
  NVML_GPM_METRIC_GR7_CTXSW_CYCLES_ACTIVE = 0xCE,
  NVML_GPM_METRIC_GR7_CTXSW_REQUESTS = 0xCF,
  NVML_GPM_METRIC_GR7_CTXSW_CYCLES_PER_REQ = 0xD0,
  NVML_GPM_METRIC_GR7_CTXSW_ACTIVE_PCT = 0xD1,
  NVML_GPM_METRIC_MAX = 0xD2
};
typedef enum nvmlGpmMetricId_t nvmlGpmMetricId_t;

/* "cy_nvml.pxd":650
 *     NVML_GPM_METRIC_MAX "NVML_GPM_METRIC_MAX" = 210
 * 
 * ctypedef enum nvmlPowerProfileType_t "nvmlPowerProfileType_t":             # <<<<<<<<<<<<<<
 *     NVML_POWER_PROFILE_MAX_P "NVML_POWER_PROFILE_MAX_P" = 0
 *     NVML_POWER_PROFILE_MAX_Q "NVML_POWER_PROFILE_MAX_Q" = 1
*/
enum nvmlPowerProfileType_t {
  NVML_POWER_PROFILE_MAX_P = 0,
  NVML_POWER_PROFILE_MAX_Q = 1,
  NVML_POWER_PROFILE_COMPUTE = 2,
  NVML_POWER_PROFILE_MEMORY_BOUND = 3,
  NVML_POWER_PROFILE_NETWORK = 4,
  NVML_POWER_PROFILE_BALANCED = 5,
  NVML_POWER_PROFILE_LLM_INFERENCE = 6,
  NVML_POWER_PROFILE_LLM_TRAINING = 7,
  NVML_POWER_PROFILE_RBM = 8,
  NVML_POWER_PROFILE_DCPCIE = 9,
  NVML_POWER_PROFILE_HMMA_SPARSE = 10,
  NVML_POWER_PROFILE_HMMA_DENSE = 11,
  NVML_POWER_PROFILE_SYNC_BALANCED = 12,
  NVML_POWER_PROFILE_HPC = 13,
  NVML_POWER_PROFILE_MIG = 14,
  NVML_POWER_PROFILE_MAX = 15
};
typedef enum nvmlPowerProfileType_t nvmlPowerProfileType_t;

/* "cy_nvml.pxd":668
 *     NVML_POWER_PROFILE_MAX "NVML_POWER_PROFILE_MAX" = 15
 * 
 * ctypedef enum nvmlDeviceAddressingModeType_t "nvmlDeviceAddressingModeType_t":             # <<<<<<<<<<<<<<
 *     NVML_DEVICE_ADDRESSING_MODE_NONE "NVML_DEVICE_ADDRESSING_MODE_NONE" = 0
 *     NVML_DEVICE_ADDRESSING_MODE_HMM "NVML_DEVICE_ADDRESSING_MODE_HMM" = 1
*/
enum nvmlDeviceAddressingModeType_t {
  NVML_DEVICE_ADDRESSING_MODE_NONE = 0,
  NVML_DEVICE_ADDRESSING_MODE_HMM = 1,
  NVML_DEVICE_ADDRESSING_MODE_ATS = 2
};
typedef enum nvmlDeviceAddressingModeType_t nvmlDeviceAddressingModeType_t;

/* "cy_nvml.pxd":675
 * 
 * # types
 * ctypedef struct nvmlPciInfoExt_v1_t 'nvmlPciInfoExt_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int domain
*/
struct nvmlPciInfoExt_v1_t {
  unsigned int version;
  unsigned int domain;
  unsigned int bus;
  unsigned int device;
  unsigned int pciDeviceId;
  unsigned int pciSubSystemId;
  unsigned int baseClass;
  unsigned int subClass;
  char busId[32];
};

/* "cy_nvml.pxd":686
 *     char busId[32]
 * 
 * ctypedef struct nvmlCoolerInfo_v1_t 'nvmlCoolerInfo_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int index
*/
struct nvmlCoolerInfo_v1_t {
  unsigned int version;
  unsigned int index;
  nvmlCoolerControl_t signalType;
  nvmlCoolerTarget_t target;
};

/* "cy_nvml.pxd":692
 *     nvmlCoolerTarget_t target
 * 
 * ctypedef struct nvmlDramEncryptionInfo_v1_t 'nvmlDramEncryptionInfo_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     nvmlEnableState_t encryptionState
*/
struct nvmlDramEncryptionInfo_v1_t {
  unsigned int version;
  nvmlEnableState_t encryptionState;
};

/* "cy_nvml.pxd":696
 *     nvmlEnableState_t encryptionState
 * 
 * ctypedef struct nvmlMarginTemperature_v1_t 'nvmlMarginTemperature_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     int marginTemperature
*/
struct nvmlMarginTemperature_v1_t {
  unsigned int version;
  int marginTemperature;
};

/* "cy_nvml.pxd":700
 *     int marginTemperature
 * 
 * ctypedef struct nvmlClockOffset_v1_t 'nvmlClockOffset_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     nvmlClockType_t type
*/
struct nvmlClockOffset_v1_t {
  unsigned int version;
  nvmlClockType_t type;
  nvmlPstates_t pstate;
  int clockOffsetMHz;
  int minClockOffsetMHz;
  int maxClockOffsetMHz;
};

/* "cy_nvml.pxd":708
 *     int maxClockOffsetMHz
 * 
 * ctypedef struct nvmlFanSpeedInfo_v1_t 'nvmlFanSpeedInfo_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int fan
*/
struct nvmlFanSpeedInfo_v1_t {
  unsigned int version;
  unsigned int fan;
  unsigned int speed;
};

/* "cy_nvml.pxd":713
 *     unsigned int speed
 * 
 * ctypedef struct nvmlDevicePerfModes_v1_t 'nvmlDevicePerfModes_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     char str[2048]
*/
struct nvmlDevicePerfModes_v1_t {
  unsigned int version;
  char str[2048];
};

/* "cy_nvml.pxd":717
 *     char str[2048]
 * 
 * ctypedef struct nvmlDeviceCurrentClockFreqs_v1_t 'nvmlDeviceCurrentClockFreqs_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     char str[2048]
*/
struct nvmlDeviceCurrentClockFreqs_v1_t {
  unsigned int version;
  char str[2048];
};

/* "cy_nvml.pxd":721
 *     char str[2048]
 * 
 * ctypedef struct nvmlEccSramErrorStatus_v1_t 'nvmlEccSramErrorStatus_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned long long aggregateUncParity
*/
struct nvmlEccSramErrorStatus_v1_t {
  unsigned int version;
  unsigned PY_LONG_LONG aggregateUncParity;
  unsigned PY_LONG_LONG aggregateUncSecDed;
  unsigned PY_LONG_LONG aggregateCor;
  unsigned PY_LONG_LONG volatileUncParity;
  unsigned PY_LONG_LONG volatileUncSecDed;
  unsigned PY_LONG_LONG volatileCor;
  unsigned PY_LONG_LONG aggregateUncBucketL2;
  unsigned PY_LONG_LONG aggregateUncBucketSm;
  unsigned PY_LONG_LONG aggregateUncBucketPcie;
  unsigned PY_LONG_LONG aggregateUncBucketMcu;
  unsigned PY_LONG_LONG aggregateUncBucketOther;
  unsigned int bThresholdExceeded;
};

/* "cy_nvml.pxd":736
 *     unsigned int bThresholdExceeded
 * 
 * ctypedef struct nvmlPlatformInfo_v2_t 'nvmlPlatformInfo_v2_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned char ibGuid[16]
*/
struct nvmlPlatformInfo_v2_t {
  unsigned int version;
  unsigned char ibGuid[16];
  unsigned char chassisSerialNumber[16];
  unsigned char slotNumber;
  unsigned char trayIndex;
  unsigned char hostId;
  unsigned char peerType;
  unsigned char moduleId;
};

/* "cy_nvml.pxd":753
 * ctypedef unsigned int nvmlVgpuTypeId_t 'nvmlVgpuTypeId_t'
 * ctypedef unsigned int nvmlVgpuInstance_t 'nvmlVgpuInstance_t'
 * ctypedef struct nvmlVgpuHeterogeneousMode_v1_t 'nvmlVgpuHeterogeneousMode_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int mode
*/
struct nvmlVgpuHeterogeneousMode_v1_t {
  unsigned int version;
  unsigned int mode;
};

/* "cy_nvml.pxd":757
 *     unsigned int mode
 * 
 * ctypedef struct nvmlVgpuPlacementId_v1_t 'nvmlVgpuPlacementId_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int placementId
*/
struct nvmlVgpuPlacementId_v1_t {
  unsigned int version;
  unsigned int placementId;
};

/* "cy_nvml.pxd":761
 *     unsigned int placementId
 * 
 * ctypedef struct nvmlVgpuPlacementList_v2_t 'nvmlVgpuPlacementList_v2_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int placementSize
*/
struct nvmlVgpuPlacementList_v2_t {
  unsigned int version;
  unsigned int placementSize;
  unsigned int count;
  unsigned int *placementIds;
  unsigned int mode;
};

/* "cy_nvml.pxd":768
 *     unsigned int mode
 * 
 * ctypedef struct nvmlVgpuTypeBar1Info_v1_t 'nvmlVgpuTypeBar1Info_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned long long bar1Size
*/
struct nvmlVgpuTypeBar1Info_v1_t {
  unsigned int version;
  unsigned PY_LONG_LONG bar1Size;
};

/* "cy_nvml.pxd":772
 *     unsigned long long bar1Size
 * 
 * ctypedef struct nvmlVgpuRuntimeState_v1_t 'nvmlVgpuRuntimeState_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned long long size
*/
struct nvmlVgpuRuntimeState_v1_t {
  unsigned int version;
  unsigned PY_LONG_LONG size;
};

/* "cy_nvml.pxd":776
 *     unsigned long long size
 * 
 * ctypedef struct nvmlSystemConfComputeSettings_v1_t 'nvmlSystemConfComputeSettings_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int environment
*/
struct nvmlSystemConfComputeSettings_v1_t {
  unsigned int version;
  unsigned int environment;
  unsigned int ccFeature;
  unsigned int devToolsMode;
  unsigned int multiGpuMode;
};

/* "cy_nvml.pxd":783
 *     unsigned int multiGpuMode
 * 
 * ctypedef struct nvmlConfComputeSetKeyRotationThresholdInfo_v1_t 'nvmlConfComputeSetKeyRotationThresholdInfo_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned long long maxAttackerAdvantage
*/
struct nvmlConfComputeSetKeyRotationThresholdInfo_v1_t {
  unsigned int version;
  unsigned PY_LONG_LONG maxAttackerAdvantage;
};

/* "cy_nvml.pxd":787
 *     unsigned long long maxAttackerAdvantage
 * 
 * ctypedef struct nvmlConfComputeGetKeyRotationThresholdInfo_v1_t 'nvmlConfComputeGetKeyRotationThresholdInfo_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned long long attackerAdvantage
*/
struct nvmlConfComputeGetKeyRotationThresholdInfo_v1_t {
  unsigned int version;
  unsigned PY_LONG_LONG attackerAdvantage;
};

/* "cy_nvml.pxd":792
 * 
 * ctypedef unsigned char nvmlGpuFabricState_t 'nvmlGpuFabricState_t'
 * ctypedef struct nvmlSystemDriverBranchInfo_v1_t 'nvmlSystemDriverBranchInfo_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     char branch[80]
*/
struct nvmlSystemDriverBranchInfo_v1_t {
  unsigned int version;
  char branch[80];
};

/* "cy_nvml.pxd":797
 * 
 * ctypedef unsigned int nvmlAffinityScope_t 'nvmlAffinityScope_t'
 * ctypedef struct nvmlTemperature_v1_t 'nvmlTemperature_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     nvmlTemperatureSensors_t sensorType
*/
struct nvmlTemperature_v1_t {
  unsigned int version;
  nvmlTemperatureSensors_t sensorType;
  int temperature;
};

/* "cy_nvml.pxd":802
 *     int temperature
 * 
 * ctypedef struct nvmlNvlinkSupportedBwModes_v1_t 'nvmlNvlinkSupportedBwModes_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned char bwModes[23]
*/
struct nvmlNvlinkSupportedBwModes_v1_t {
  unsigned int version;
  unsigned char bwModes[23];
  unsigned char totalBwModes;
};

/* "cy_nvml.pxd":807
 *     unsigned char totalBwModes
 * 
 * ctypedef struct nvmlNvlinkGetBwMode_v1_t 'nvmlNvlinkGetBwMode_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int bIsBest
*/
struct nvmlNvlinkGetBwMode_v1_t {
  unsigned int version;
  unsigned int bIsBest;
  unsigned char bwMode;
};

/* "cy_nvml.pxd":812
 *     unsigned char bwMode
 * 
 * ctypedef struct nvmlNvlinkSetBwMode_v1_t 'nvmlNvlinkSetBwMode_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int bSetBest
*/
struct nvmlNvlinkSetBwMode_v1_t {
  unsigned int version;
  unsigned int bSetBest;
  unsigned char bwMode;
};

/* "cy_nvml.pxd":817
 *     unsigned char bwMode
 * 
 * ctypedef struct nvmlDeviceCapabilities_v1_t 'nvmlDeviceCapabilities_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int capMask
*/
struct nvmlDeviceCapabilities_v1_t {
  unsigned int version;
  unsigned int capMask;
};

/* "cy_nvml.pxd":821
 *     unsigned int capMask
 * 
 * ctypedef struct nvmlPowerSmoothingProfile_v1_t 'nvmlPowerSmoothingProfile_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int profileId
*/
struct nvmlPowerSmoothingProfile_v1_t {
  unsigned int version;
  unsigned int profileId;
  unsigned int paramId;
  double value;
};

/* "cy_nvml.pxd":827
 *     double value
 * 
 * ctypedef struct nvmlPowerSmoothingState_v1_t 'nvmlPowerSmoothingState_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     nvmlEnableState_t state
*/
struct nvmlPowerSmoothingState_v1_t {
  unsigned int version;
  nvmlEnableState_t state;
};

/* "cy_nvml.pxd":831
 *     nvmlEnableState_t state
 * 
 * ctypedef struct nvmlDeviceAddressingMode_v1_t 'nvmlDeviceAddressingMode_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int value
*/
struct nvmlDeviceAddressingMode_v1_t {
  unsigned int version;
  unsigned int value;
};

/* "cy_nvml.pxd":835
 *     unsigned int value
 * 
 * ctypedef struct nvmlRepairStatus_v1_t 'nvmlRepairStatus_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int bChannelRepairPending
*/
struct nvmlRepairStatus_v1_t {
  unsigned int version;
  unsigned int bChannelRepairPending;
  unsigned int bTpcRepairPending;
};

/* "cy_nvml.pxd":840
 *     unsigned int bTpcRepairPending
 * 
 * ctypedef struct nvmlPdi_v1_t 'nvmlPdi_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned long long value
*/
struct nvmlPdi_v1_t {
  unsigned int version;
  unsigned PY_LONG_LONG value;
};

/* "cy_nvml.pxd":844
 *     unsigned long long value
 * 
 * ctypedef void* nvmlDevice_t 'nvmlDevice_t'             # <<<<<<<<<<<<<<
 * ctypedef void* nvmlGpuInstance_t 'nvmlGpuInstance_t'
 * ctypedef void* nvmlUnit_t 'nvmlUnit_t'
*/
typedef void *nvmlDevice_t;

/* "cy_nvml.pxd":845
 * 
 * ctypedef void* nvmlDevice_t 'nvmlDevice_t'
 * ctypedef void* nvmlGpuInstance_t 'nvmlGpuInstance_t'             # <<<<<<<<<<<<<<
 * ctypedef void* nvmlUnit_t 'nvmlUnit_t'
 * ctypedef void* nvmlEventSet_t 'nvmlEventSet_t'
*/
typedef void *nvmlGpuInstance_t;

/* "cy_nvml.pxd":846
 * ctypedef void* nvmlDevice_t 'nvmlDevice_t'
 * ctypedef void* nvmlGpuInstance_t 'nvmlGpuInstance_t'
 * ctypedef void* nvmlUnit_t 'nvmlUnit_t'             # <<<<<<<<<<<<<<
 * ctypedef void* nvmlEventSet_t 'nvmlEventSet_t'
 * ctypedef void* nvmlSystemEventSet_t 'nvmlSystemEventSet_t'
*/
typedef void *nvmlUnit_t;

/* "cy_nvml.pxd":847
 * ctypedef void* nvmlGpuInstance_t 'nvmlGpuInstance_t'
 * ctypedef void* nvmlUnit_t 'nvmlUnit_t'
 * ctypedef void* nvmlEventSet_t 'nvmlEventSet_t'             # <<<<<<<<<<<<<<
 * ctypedef void* nvmlSystemEventSet_t 'nvmlSystemEventSet_t'
 * ctypedef void* nvmlComputeInstance_t 'nvmlComputeInstance_t'
*/
typedef void *nvmlEventSet_t;

/* "cy_nvml.pxd":848
 * ctypedef void* nvmlUnit_t 'nvmlUnit_t'
 * ctypedef void* nvmlEventSet_t 'nvmlEventSet_t'
 * ctypedef void* nvmlSystemEventSet_t 'nvmlSystemEventSet_t'             # <<<<<<<<<<<<<<
 * ctypedef void* nvmlComputeInstance_t 'nvmlComputeInstance_t'
 * ctypedef void* nvmlGpmSample_t 'nvmlGpmSample_t'
*/
typedef void *nvmlSystemEventSet_t;

/* "cy_nvml.pxd":849
 * ctypedef void* nvmlEventSet_t 'nvmlEventSet_t'
 * ctypedef void* nvmlSystemEventSet_t 'nvmlSystemEventSet_t'
 * ctypedef void* nvmlComputeInstance_t 'nvmlComputeInstance_t'             # <<<<<<<<<<<<<<
 * ctypedef void* nvmlGpmSample_t 'nvmlGpmSample_t'
 * ctypedef struct nvmlPciInfo_t 'nvmlPciInfo_t':
*/
typedef void *nvmlComputeInstance_t;

/* "cy_nvml.pxd":850
 * ctypedef void* nvmlSystemEventSet_t 'nvmlSystemEventSet_t'
 * ctypedef void* nvmlComputeInstance_t 'nvmlComputeInstance_t'
 * ctypedef void* nvmlGpmSample_t 'nvmlGpmSample_t'             # <<<<<<<<<<<<<<
 * ctypedef struct nvmlPciInfo_t 'nvmlPciInfo_t':
 *     char busIdLegacy[16]
*/
typedef void *nvmlGpmSample_t;

/* "cy_nvml.pxd":851
 * ctypedef void* nvmlComputeInstance_t 'nvmlComputeInstance_t'
 * ctypedef void* nvmlGpmSample_t 'nvmlGpmSample_t'
 * ctypedef struct nvmlPciInfo_t 'nvmlPciInfo_t':             # <<<<<<<<<<<<<<
 *     char busIdLegacy[16]
 *     unsigned int domain
*/
struct nvmlPciInfo_t {
  char busIdLegacy[16];
  unsigned int domain;
  unsigned int bus;
  unsigned int device;
  unsigned int pciDeviceId;
  unsigned int pciSubSystemId;
  char busId[32];
};

/* "cy_nvml.pxd":860
 *     char busId[32]
 * 
 * ctypedef struct nvmlEccErrorCounts_t 'nvmlEccErrorCounts_t':             # <<<<<<<<<<<<<<
 *     unsigned long long l1Cache
 *     unsigned long long l2Cache
*/
struct nvmlEccErrorCounts_t {
  unsigned PY_LONG_LONG l1Cache;
  unsigned PY_LONG_LONG l2Cache;
  unsigned PY_LONG_LONG deviceMemory;
  unsigned PY_LONG_LONG registerFile;
};

/* "cy_nvml.pxd":866
 *     unsigned long long registerFile
 * 
 * ctypedef struct nvmlUtilization_t 'nvmlUtilization_t':             # <<<<<<<<<<<<<<
 *     unsigned int gpu
 *     unsigned int memory
*/
struct nvmlUtilization_t {
  unsigned int gpu;
  unsigned int memory;
};

/* "cy_nvml.pxd":870
 *     unsigned int memory
 * 
 * ctypedef struct nvmlMemory_t 'nvmlMemory_t':             # <<<<<<<<<<<<<<
 *     unsigned long long total
 *     unsigned long long free
*/
struct nvmlMemory_t {
  unsigned PY_LONG_LONG total;
  unsigned PY_LONG_LONG free;
  unsigned PY_LONG_LONG used;
};

/* "cy_nvml.pxd":875
 *     unsigned long long used
 * 
 * ctypedef struct nvmlMemory_v2_t 'nvmlMemory_v2_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned long long total
*/
struct nvmlMemory_v2_t {
  unsigned int version;
  unsigned PY_LONG_LONG total;
  unsigned PY_LONG_LONG reserved;
  unsigned PY_LONG_LONG free;
  unsigned PY_LONG_LONG used;
};

/* "cy_nvml.pxd":882
 *     unsigned long long used
 * 
 * ctypedef struct nvmlBAR1Memory_t 'nvmlBAR1Memory_t':             # <<<<<<<<<<<<<<
 *     unsigned long long bar1Total
 *     unsigned long long bar1Free
*/
struct nvmlBAR1Memory_t {
  unsigned PY_LONG_LONG bar1Total;
  unsigned PY_LONG_LONG bar1Free;
  unsigned PY_LONG_LONG bar1Used;
};

/* "cy_nvml.pxd":887
 *     unsigned long long bar1Used
 * 
 * ctypedef struct nvmlProcessInfo_v1_t 'nvmlProcessInfo_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int pid
 *     unsigned long long usedGpuMemory
*/
struct nvmlProcessInfo_v1_t {
  unsigned int pid;
  unsigned PY_LONG_LONG usedGpuMemory;
};

/* "cy_nvml.pxd":891
 *     unsigned long long usedGpuMemory
 * 
 * ctypedef struct nvmlProcessInfo_v2_t 'nvmlProcessInfo_v2_t':             # <<<<<<<<<<<<<<
 *     unsigned int pid
 *     unsigned long long usedGpuMemory
*/
struct nvmlProcessInfo_v2_t {
  unsigned int pid;
  unsigned PY_LONG_LONG usedGpuMemory;
  unsigned int gpuInstanceId;
  unsigned int computeInstanceId;
};

/* "cy_nvml.pxd":897
 *     unsigned int computeInstanceId
 * 
 * ctypedef struct nvmlProcessInfo_t 'nvmlProcessInfo_t':             # <<<<<<<<<<<<<<
 *     unsigned int pid
 *     unsigned long long usedGpuMemory
*/
struct nvmlProcessInfo_t {
  unsigned int pid;
  unsigned PY_LONG_LONG usedGpuMemory;
  unsigned int gpuInstanceId;
  unsigned int computeInstanceId;
};

/* "cy_nvml.pxd":903
 *     unsigned int computeInstanceId
 * 
 * ctypedef struct nvmlProcessDetail_v1_t 'nvmlProcessDetail_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int pid
 *     unsigned long long usedGpuMemory
*/
struct nvmlProcessDetail_v1_t {
  unsigned int pid;
  unsigned PY_LONG_LONG usedGpuMemory;
  unsigned int gpuInstanceId;
  unsigned int computeInstanceId;
  unsigned PY_LONG_LONG usedGpuCcProtectedMemory;
};

/* "cy_nvml.pxd":910
 *     unsigned long long usedGpuCcProtectedMemory
 * 
 * ctypedef struct nvmlDeviceAttributes_t 'nvmlDeviceAttributes_t':             # <<<<<<<<<<<<<<
 *     unsigned int multiprocessorCount
 *     unsigned int sharedCopyEngineCount
*/
struct nvmlDeviceAttributes_t {
  unsigned int multiprocessorCount;
  unsigned int sharedCopyEngineCount;
  unsigned int sharedDecoderCount;
  unsigned int sharedEncoderCount;
  unsigned int sharedJpegCount;
  unsigned int sharedOfaCount;
  unsigned int gpuInstanceSliceCount;
  unsigned int computeInstanceSliceCount;
  unsigned PY_LONG_LONG memorySizeMB;
};

/* "cy_nvml.pxd":921
 *     unsigned long long memorySizeMB
 * 
 * ctypedef struct nvmlC2cModeInfo_v1_t 'nvmlC2cModeInfo_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int isC2cEnabled
 * 
*/
struct nvmlC2cModeInfo_v1_t {
  unsigned int isC2cEnabled;
};

/* "cy_nvml.pxd":924
 *     unsigned int isC2cEnabled
 * 
 * ctypedef struct nvmlRowRemapperHistogramValues_t 'nvmlRowRemapperHistogramValues_t':             # <<<<<<<<<<<<<<
 *     unsigned int max
 *     unsigned int high
*/
struct nvmlRowRemapperHistogramValues_t {
  unsigned int max;
  unsigned int high;
  unsigned int partial;
  unsigned int low;
  unsigned int none;
};

/* "cy_nvml.pxd":931
 *     unsigned int none
 * 
 * ctypedef struct nvmlNvLinkUtilizationControl_t 'nvmlNvLinkUtilizationControl_t':             # <<<<<<<<<<<<<<
 *     nvmlNvLinkUtilizationCountUnits_t units
 *     nvmlNvLinkUtilizationCountPktTypes_t pktfilter
*/
struct nvmlNvLinkUtilizationControl_t {
  nvmlNvLinkUtilizationCountUnits_t units;
  nvmlNvLinkUtilizationCountPktTypes_t pktfilter;
};

/* "cy_nvml.pxd":935
 *     nvmlNvLinkUtilizationCountPktTypes_t pktfilter
 * 
 * ctypedef struct nvmlBridgeChipInfo_t 'nvmlBridgeChipInfo_t':             # <<<<<<<<<<<<<<
 *     nvmlBridgeChipType_t type
 *     unsigned int fwVersion
*/
struct nvmlBridgeChipInfo_t {
  nvmlBridgeChipType_t type;
  unsigned int fwVersion;
};

/* "cy_nvml.pxd":939
 *     unsigned int fwVersion
 * 
 * ctypedef union nvmlValue_t 'nvmlValue_t':             # <<<<<<<<<<<<<<
 *     double dVal
 *     int siVal
*/
union nvmlValue_t {
  double dVal;
  int siVal;
  unsigned int uiVal;
  unsigned long ulVal;
  unsigned PY_LONG_LONG ullVal;
  PY_LONG_LONG sllVal;
  unsigned short usVal;
};

/* "cy_nvml.pxd":948
 *     unsigned short usVal
 * 
 * ctypedef struct nvmlViolationTime_t 'nvmlViolationTime_t':             # <<<<<<<<<<<<<<
 *     unsigned long long referenceTime
 *     unsigned long long violationTime
*/
struct nvmlViolationTime_t {
  unsigned PY_LONG_LONG referenceTime;
  unsigned PY_LONG_LONG violationTime;
};

/* "cy_nvml.pxd":952
 *     unsigned long long violationTime
 * 
 * ctypedef struct _anon_pod0 '_anon_pod0':             # <<<<<<<<<<<<<<
 *     nvmlThermalController_t controller
 *     int defaultMinTemp
*/
struct _anon_pod0 {
  nvmlThermalController_t controller;
  int defaultMinTemp;
  int defaultMaxTemp;
  int currentTemp;
  nvmlThermalTarget_t target;
};

/* "cy_nvml.pxd":959
 *     nvmlThermalTarget_t target
 * 
 * ctypedef union nvmlUUIDValue_t 'nvmlUUIDValue_t':             # <<<<<<<<<<<<<<
 *     char str[41]
 *     unsigned char bytes[16]
*/
union nvmlUUIDValue_t {
  char str[41];
  unsigned char bytes[16];
};

/* "cy_nvml.pxd":963
 *     unsigned char bytes[16]
 * 
 * ctypedef struct nvmlClkMonFaultInfo_t 'nvmlClkMonFaultInfo_t':             # <<<<<<<<<<<<<<
 *     unsigned int clkApiDomain
 *     unsigned int clkDomainFaultMask
*/
struct nvmlClkMonFaultInfo_t {
  unsigned int clkApiDomain;
  unsigned int clkDomainFaultMask;
};

/* "cy_nvml.pxd":967
 *     unsigned int clkDomainFaultMask
 * 
 * ctypedef struct nvmlProcessUtilizationSample_t 'nvmlProcessUtilizationSample_t':             # <<<<<<<<<<<<<<
 *     unsigned int pid
 *     unsigned long long timeStamp
*/
struct nvmlProcessUtilizationSample_t {
  unsigned int pid;
  unsigned PY_LONG_LONG timeStamp;
  unsigned int smUtil;
  unsigned int memUtil;
  unsigned int encUtil;
  unsigned int decUtil;
};

/* "cy_nvml.pxd":975
 *     unsigned int decUtil
 * 
 * ctypedef struct nvmlProcessUtilizationInfo_v1_t 'nvmlProcessUtilizationInfo_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned long long timeStamp
 *     unsigned int pid
*/
struct nvmlProcessUtilizationInfo_v1_t {
  unsigned PY_LONG_LONG timeStamp;
  unsigned int pid;
  unsigned int smUtil;
  unsigned int memUtil;
  unsigned int encUtil;
  unsigned int decUtil;
  unsigned int jpgUtil;
  unsigned int ofaUtil;
};

/* "cy_nvml.pxd":985
 *     unsigned int ofaUtil
 * 
 * ctypedef struct nvmlPlatformInfo_v1_t 'nvmlPlatformInfo_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned char ibGuid[16]
*/
struct nvmlPlatformInfo_v1_t {
  unsigned int version;
  unsigned char ibGuid[16];
  unsigned char rackGuid[16];
  unsigned char chassisPhysicalSlotNumber;
  unsigned char computeSlotIndex;
  unsigned char nodeIndex;
  unsigned char peerType;
  unsigned char moduleId;
};

/* "cy_nvml.pxd":995
 *     unsigned char moduleId
 * 
 * ctypedef struct _anon_pod1 '_anon_pod1':             # <<<<<<<<<<<<<<
 *     unsigned int bIsPresent
 *     unsigned int percentage
*/
struct _anon_pod1 {
  unsigned int bIsPresent;
  unsigned int percentage;
  unsigned int incThreshold;
  unsigned int decThreshold;
};

/* "cy_nvml.pxd":1001
 *     unsigned int decThreshold
 * 
 * ctypedef struct nvmlVgpuPlacementList_v1_t 'nvmlVgpuPlacementList_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int placementSize
*/
struct nvmlVgpuPlacementList_v1_t {
  unsigned int version;
  unsigned int placementSize;
  unsigned int count;
  unsigned int *placementIds;
};

/* "cy_nvml.pxd":1007
 *     unsigned int* placementIds
 * 
 * ctypedef struct _anon_pod2 '_anon_pod2':             # <<<<<<<<<<<<<<
 *     unsigned int avgFactor
 *     unsigned int timeslice
*/
struct _anon_pod2 {
  unsigned int avgFactor;
  unsigned int timeslice;
};

/* "cy_nvml.pxd":1011
 *     unsigned int timeslice
 * 
 * ctypedef struct _anon_pod3 '_anon_pod3':             # <<<<<<<<<<<<<<
 *     unsigned int timeslice
 * 
*/
struct _anon_pod3 {
  unsigned int timeslice;
};

/* "cy_nvml.pxd":1014
 *     unsigned int timeslice
 * 
 * ctypedef struct nvmlVgpuSchedulerLogEntry_t 'nvmlVgpuSchedulerLogEntry_t':             # <<<<<<<<<<<<<<
 *     unsigned long long timestamp
 *     unsigned long long timeRunTotal
*/
struct nvmlVgpuSchedulerLogEntry_t {
  unsigned PY_LONG_LONG timestamp;
  unsigned PY_LONG_LONG timeRunTotal;
  unsigned PY_LONG_LONG timeRun;
  unsigned int swRunlistId;
  unsigned PY_LONG_LONG targetTimeSlice;
  unsigned PY_LONG_LONG cumulativePreemptionTime;
};

/* "cy_nvml.pxd":1022
 *     unsigned long long cumulativePreemptionTime
 * 
 * ctypedef struct _anon_pod4 '_anon_pod4':             # <<<<<<<<<<<<<<
 *     unsigned int avgFactor
 *     unsigned int frequency
*/
struct _anon_pod4 {
  unsigned int avgFactor;
  unsigned int frequency;
};

/* "cy_nvml.pxd":1026
 *     unsigned int frequency
 * 
 * ctypedef struct _anon_pod5 '_anon_pod5':             # <<<<<<<<<<<<<<
 *     unsigned int timeslice
 * 
*/
struct _anon_pod5 {
  unsigned int timeslice;
};

/* "cy_nvml.pxd":1029
 *     unsigned int timeslice
 * 
 * ctypedef struct nvmlVgpuSchedulerCapabilities_t 'nvmlVgpuSchedulerCapabilities_t':             # <<<<<<<<<<<<<<
 *     unsigned int supportedSchedulers[3]
 *     unsigned int maxTimeslice
*/
struct nvmlVgpuSchedulerCapabilities_t {
  unsigned int supportedSchedulers[3];
  unsigned int maxTimeslice;
  unsigned int minTimeslice;
  unsigned int isArrModeSupported;
  unsigned int maxFrequencyForARR;
  unsigned int minFrequencyForARR;
  unsigned int maxAvgFactorForARR;
  unsigned int minAvgFactorForARR;
};

/* "cy_nvml.pxd":1039
 *     unsigned int minAvgFactorForARR
 * 
 * ctypedef struct nvmlVgpuLicenseExpiry_t 'nvmlVgpuLicenseExpiry_t':             # <<<<<<<<<<<<<<
 *     unsigned int year
 *     unsigned short month
*/
struct nvmlVgpuLicenseExpiry_t {
  unsigned int year;
  unsigned short month;
  unsigned short day;
  unsigned short hour;
  unsigned short min;
  unsigned short sec;
  unsigned char status;
};

/* "cy_nvml.pxd":1048
 *     unsigned char status
 * 
 * ctypedef struct nvmlGridLicenseExpiry_t 'nvmlGridLicenseExpiry_t':             # <<<<<<<<<<<<<<
 *     unsigned int year
 *     unsigned short month
*/
struct nvmlGridLicenseExpiry_t {
  unsigned int year;
  unsigned short month;
  unsigned short day;
  unsigned short hour;
  unsigned short min;
  unsigned short sec;
  unsigned char status;
};

/* "cy_nvml.pxd":1057
 *     unsigned char status
 * 
 * ctypedef struct nvmlNvLinkPowerThres_t 'nvmlNvLinkPowerThres_t':             # <<<<<<<<<<<<<<
 *     unsigned int lowPwrThreshold
 * 
*/
struct nvmlNvLinkPowerThres_t {
  unsigned int lowPwrThreshold;
};

/* "cy_nvml.pxd":1060
 *     unsigned int lowPwrThreshold
 * 
 * ctypedef struct nvmlHwbcEntry_t 'nvmlHwbcEntry_t':             # <<<<<<<<<<<<<<
 *     unsigned int hwbcId
 *     char firmwareVersion[32]
*/
struct nvmlHwbcEntry_t {
  unsigned int hwbcId;
  char firmwareVersion[32];
};

/* "cy_nvml.pxd":1064
 *     char firmwareVersion[32]
 * 
 * ctypedef struct nvmlLedState_t 'nvmlLedState_t':             # <<<<<<<<<<<<<<
 *     char cause[256]
 *     nvmlLedColor_t color
*/
struct nvmlLedState_t {
  char cause[256];
  nvmlLedColor_t color;
};

/* "cy_nvml.pxd":1068
 *     nvmlLedColor_t color
 * 
 * ctypedef struct nvmlUnitInfo_t 'nvmlUnitInfo_t':             # <<<<<<<<<<<<<<
 *     char name[96]
 *     char id[96]
*/
struct nvmlUnitInfo_t {
  char name[96];
  char id[96];
  char serial[96];
  char firmwareVersion[96];
};

/* "cy_nvml.pxd":1074
 *     char firmwareVersion[96]
 * 
 * ctypedef struct nvmlPSUInfo_t 'nvmlPSUInfo_t':             # <<<<<<<<<<<<<<
 *     char state[256]
 *     unsigned int current
*/
struct nvmlPSUInfo_t {
  char state[256];
  unsigned int current;
  unsigned int voltage;
  unsigned int power;
};

/* "cy_nvml.pxd":1080
 *     unsigned int power
 * 
 * ctypedef struct nvmlUnitFanInfo_t 'nvmlUnitFanInfo_t':             # <<<<<<<<<<<<<<
 *     unsigned int speed
 *     nvmlFanState_t state
*/
struct nvmlUnitFanInfo_t {
  unsigned int speed;
  nvmlFanState_t state;
};

/* "cy_nvml.pxd":1084
 *     nvmlFanState_t state
 * 
 * ctypedef struct nvmlSystemEventData_v1_t 'nvmlSystemEventData_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned long long eventType
 *     unsigned int gpuId
*/
struct nvmlSystemEventData_v1_t {
  unsigned PY_LONG_LONG eventType;
  unsigned int gpuId;
};

/* "cy_nvml.pxd":1088
 *     unsigned int gpuId
 * 
 * ctypedef struct nvmlAccountingStats_t 'nvmlAccountingStats_t':             # <<<<<<<<<<<<<<
 *     unsigned int gpuUtilization
 *     unsigned int memoryUtilization
*/
struct nvmlAccountingStats_t {
  unsigned int gpuUtilization;
  unsigned int memoryUtilization;
  unsigned PY_LONG_LONG maxMemoryUsage;
  unsigned PY_LONG_LONG time;
  unsigned PY_LONG_LONG startTime;
  unsigned int isRunning;
  unsigned int reserved[5];
};

/* "cy_nvml.pxd":1097
 *     unsigned int reserved[5]
 * 
 * ctypedef struct nvmlFBCStats_t 'nvmlFBCStats_t':             # <<<<<<<<<<<<<<
 *     unsigned int sessionsCount
 *     unsigned int averageFPS
*/
struct nvmlFBCStats_t {
  unsigned int sessionsCount;
  unsigned int averageFPS;
  unsigned int averageLatency;
};

/* "cy_nvml.pxd":1102
 *     unsigned int averageLatency
 * 
 * ctypedef struct nvmlConfComputeSystemCaps_t 'nvmlConfComputeSystemCaps_t':             # <<<<<<<<<<<<<<
 *     unsigned int cpuCaps
 *     unsigned int gpusCaps
*/
struct nvmlConfComputeSystemCaps_t {
  unsigned int cpuCaps;
  unsigned int gpusCaps;
};

/* "cy_nvml.pxd":1106
 *     unsigned int gpusCaps
 * 
 * ctypedef struct nvmlConfComputeSystemState_t 'nvmlConfComputeSystemState_t':             # <<<<<<<<<<<<<<
 *     unsigned int environment
 *     unsigned int ccFeature
*/
struct nvmlConfComputeSystemState_t {
  unsigned int environment;
  unsigned int ccFeature;
  unsigned int devToolsMode;
};

/* "cy_nvml.pxd":1111
 *     unsigned int devToolsMode
 * 
 * ctypedef struct nvmlConfComputeMemSizeInfo_t 'nvmlConfComputeMemSizeInfo_t':             # <<<<<<<<<<<<<<
 *     unsigned long long protectedMemSizeKib
 *     unsigned long long unprotectedMemSizeKib
*/
struct nvmlConfComputeMemSizeInfo_t {
  unsigned PY_LONG_LONG protectedMemSizeKib;
  unsigned PY_LONG_LONG unprotectedMemSizeKib;
};

/* "cy_nvml.pxd":1115
 *     unsigned long long unprotectedMemSizeKib
 * 
 * ctypedef struct nvmlConfComputeGpuCertificate_t 'nvmlConfComputeGpuCertificate_t':             # <<<<<<<<<<<<<<
 *     unsigned int certChainSize
 *     unsigned int attestationCertChainSize
*/
struct nvmlConfComputeGpuCertificate_t {
  unsigned int certChainSize;
  unsigned int attestationCertChainSize;
  unsigned char certChain[4096];
  unsigned char attestationCertChain[5120];
};

/* "cy_nvml.pxd":1121
 *     unsigned char attestationCertChain[0x1400]
 * 
 * ctypedef struct nvmlConfComputeGpuAttestationReport_t 'nvmlConfComputeGpuAttestationReport_t':             # <<<<<<<<<<<<<<
 *     unsigned int isCecAttestationReportPresent
 *     unsigned int attestationReportSize
*/
struct nvmlConfComputeGpuAttestationReport_t {
  unsigned int isCecAttestationReportPresent;
  unsigned int attestationReportSize;
  unsigned int cecAttestationReportSize;
  unsigned char nonce[32];
  unsigned char attestationReport[8192];
  unsigned char cecAttestationReport[4096];
};

/* "cy_nvml.pxd":1129
 *     unsigned char cecAttestationReport[0x1000]
 * 
 * ctypedef struct nvmlVgpuVersion_t 'nvmlVgpuVersion_t':             # <<<<<<<<<<<<<<
 *     unsigned int minVersion
 *     unsigned int maxVersion
*/
struct nvmlVgpuVersion_t {
  unsigned int minVersion;
  unsigned int maxVersion;
};

/* "cy_nvml.pxd":1133
 *     unsigned int maxVersion
 * 
 * ctypedef struct nvmlVgpuMetadata_t 'nvmlVgpuMetadata_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int revision
*/
struct nvmlVgpuMetadata_t {
  unsigned int version;
  unsigned int revision;
  nvmlVgpuGuestInfoState_t guestInfoState;
  char guestDriverVersion[80];
  char hostDriverVersion[80];
  unsigned int reserved[6];
  unsigned int vgpuVirtualizationCaps;
  unsigned int guestVgpuVersion;
  unsigned int opaqueDataSize;
  char opaqueData[4];
};

/* "cy_nvml.pxd":1145
 *     char opaqueData[4]
 * 
 * ctypedef struct nvmlVgpuPgpuCompatibility_t 'nvmlVgpuPgpuCompatibility_t':             # <<<<<<<<<<<<<<
 *     nvmlVgpuVmCompatibility_t vgpuVmCompatibility
 *     nvmlVgpuPgpuCompatibilityLimitCode_t compatibilityLimitCode
*/
struct nvmlVgpuPgpuCompatibility_t {
  nvmlVgpuVmCompatibility_t vgpuVmCompatibility;
  nvmlVgpuPgpuCompatibilityLimitCode_t compatibilityLimitCode;
};

/* "cy_nvml.pxd":1149
 *     nvmlVgpuPgpuCompatibilityLimitCode_t compatibilityLimitCode
 * 
 * ctypedef struct nvmlGpuInstancePlacement_t 'nvmlGpuInstancePlacement_t':             # <<<<<<<<<<<<<<
 *     unsigned int start
 *     unsigned int size
*/
struct nvmlGpuInstancePlacement_t {
  unsigned int start;
  unsigned int size;
};

/* "cy_nvml.pxd":1153
 *     unsigned int size
 * 
 * ctypedef struct nvmlGpuInstanceProfileInfo_t 'nvmlGpuInstanceProfileInfo_t':             # <<<<<<<<<<<<<<
 *     unsigned int id
 *     unsigned int isP2pSupported
*/
struct nvmlGpuInstanceProfileInfo_t {
  unsigned int id;
  unsigned int isP2pSupported;
  unsigned int sliceCount;
  unsigned int instanceCount;
  unsigned int multiprocessorCount;
  unsigned int copyEngineCount;
  unsigned int decoderCount;
  unsigned int encoderCount;
  unsigned int jpegCount;
  unsigned int ofaCount;
  unsigned PY_LONG_LONG memorySizeMB;
};

/* "cy_nvml.pxd":1166
 *     unsigned long long memorySizeMB
 * 
 * ctypedef struct nvmlGpuInstanceProfileInfo_v2_t 'nvmlGpuInstanceProfileInfo_v2_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int id
*/
struct nvmlGpuInstanceProfileInfo_v2_t {
  unsigned int version;
  unsigned int id;
  unsigned int isP2pSupported;
  unsigned int sliceCount;
  unsigned int instanceCount;
  unsigned int multiprocessorCount;
  unsigned int copyEngineCount;
  unsigned int decoderCount;
  unsigned int encoderCount;
  unsigned int jpegCount;
  unsigned int ofaCount;
  unsigned PY_LONG_LONG memorySizeMB;
  char name[96];
};

/* "cy_nvml.pxd":1181
 *     char name[96]
 * 
 * ctypedef struct nvmlGpuInstanceProfileInfo_v3_t 'nvmlGpuInstanceProfileInfo_v3_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int id
*/
struct nvmlGpuInstanceProfileInfo_v3_t {
  unsigned int version;
  unsigned int id;
  unsigned int sliceCount;
  unsigned int instanceCount;
  unsigned int multiprocessorCount;
  unsigned int copyEngineCount;
  unsigned int decoderCount;
  unsigned int encoderCount;
  unsigned int jpegCount;
  unsigned int ofaCount;
  unsigned PY_LONG_LONG memorySizeMB;
  char name[96];
  unsigned int capabilities;
};

/* "cy_nvml.pxd":1196
 *     unsigned int capabilities
 * 
 * ctypedef struct nvmlComputeInstancePlacement_t 'nvmlComputeInstancePlacement_t':             # <<<<<<<<<<<<<<
 *     unsigned int start
 *     unsigned int size
*/
struct nvmlComputeInstancePlacement_t {
  unsigned int start;
  unsigned int size;
};

/* "cy_nvml.pxd":1200
 *     unsigned int size
 * 
 * ctypedef struct nvmlComputeInstanceProfileInfo_t 'nvmlComputeInstanceProfileInfo_t':             # <<<<<<<<<<<<<<
 *     unsigned int id
 *     unsigned int sliceCount
*/
struct nvmlComputeInstanceProfileInfo_t {
  unsigned int id;
  unsigned int sliceCount;
  unsigned int instanceCount;
  unsigned int multiprocessorCount;
  unsigned int sharedCopyEngineCount;
  unsigned int sharedDecoderCount;
  unsigned int sharedEncoderCount;
  unsigned int sharedJpegCount;
  unsigned int sharedOfaCount;
};

/* "cy_nvml.pxd":1211
 *     unsigned int sharedOfaCount
 * 
 * ctypedef struct nvmlComputeInstanceProfileInfo_v2_t 'nvmlComputeInstanceProfileInfo_v2_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int id
*/
struct nvmlComputeInstanceProfileInfo_v2_t {
  unsigned int version;
  unsigned int id;
  unsigned int sliceCount;
  unsigned int instanceCount;
  unsigned int multiprocessorCount;
  unsigned int sharedCopyEngineCount;
  unsigned int sharedDecoderCount;
  unsigned int sharedEncoderCount;
  unsigned int sharedJpegCount;
  unsigned int sharedOfaCount;
  char name[96];
};

/* "cy_nvml.pxd":1224
 *     char name[96]
 * 
 * ctypedef struct nvmlComputeInstanceProfileInfo_v3_t 'nvmlComputeInstanceProfileInfo_v3_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int id
*/
struct nvmlComputeInstanceProfileInfo_v3_t {
  unsigned int version;
  unsigned int id;
  unsigned int sliceCount;
  unsigned int instanceCount;
  unsigned int multiprocessorCount;
  unsigned int sharedCopyEngineCount;
  unsigned int sharedDecoderCount;
  unsigned int sharedEncoderCount;
  unsigned int sharedJpegCount;
  unsigned int sharedOfaCount;
  char name[96];
  unsigned int capabilities;
};

/* "cy_nvml.pxd":1238
 *     unsigned int capabilities
 * 
 * ctypedef struct _anon_pod6 '_anon_pod6':             # <<<<<<<<<<<<<<
 *     char* shortName
 *     char* longName
*/
struct _anon_pod6 {
  char *shortName;
  char *longName;
  char *unit;
};

/* "cy_nvml.pxd":1243
 *     char* unit
 * 
 * ctypedef struct nvmlGpmSupport_t 'nvmlGpmSupport_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int isSupportedDevice
*/
struct nvmlGpmSupport_t {
  unsigned int version;
  unsigned int isSupportedDevice;
};

/* "cy_nvml.pxd":1247
 *     unsigned int isSupportedDevice
 * 
 * ctypedef struct nvmlMask255_t 'nvmlMask255_t':             # <<<<<<<<<<<<<<
 *     unsigned int mask[8]
 * 
*/
struct nvmlMask255_t {
  unsigned int mask[8];
};

/* "cy_nvml.pxd":1250
 *     unsigned int mask[8]
 * 
 * ctypedef struct nvmlDevicePowerMizerModes_v1_t 'nvmlDevicePowerMizerModes_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int currentMode
 *     unsigned int mode
*/
struct nvmlDevicePowerMizerModes_v1_t {
  unsigned int currentMode;
  unsigned int mode;
  unsigned int supportedPowerMizerModes;
};

/* "cy_nvml.pxd":1255
 *     unsigned int supportedPowerMizerModes
 * 
 * ctypedef struct nvmlHostname_v1_t 'nvmlHostname_v1_t':             # <<<<<<<<<<<<<<
 *     char value[64]
 * 
*/
struct nvmlHostname_v1_t {
  char value[64];
};

/* "cy_nvml.pxd":1258
 *     char value[64]
 * 
 * ctypedef struct nvmlEccSramUniqueUncorrectedErrorEntry_v1_t 'nvmlEccSramUniqueUncorrectedErrorEntry_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int unit
 *     unsigned int location
*/
struct nvmlEccSramUniqueUncorrectedErrorEntry_v1_t {
  unsigned int unit;
  unsigned int location;
  unsigned int sublocation;
  unsigned int extlocation;
  unsigned int address;
  unsigned int isParity;
  unsigned int count;
};

/* "cy_nvml.pxd":1267
 *     unsigned int count
 * 
 * ctypedef struct nvmlNvLinkInfo_v1_t 'nvmlNvLinkInfo_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int isNvleEnabled
*/
struct nvmlNvLinkInfo_v1_t {
  unsigned int version;
  unsigned int isNvleEnabled;
};

/* "cy_nvml.pxd":1271
 *     unsigned int isNvleEnabled
 * 
 * ctypedef struct nvmlNvlinkFirmwareVersion_t 'nvmlNvlinkFirmwareVersion_t':             # <<<<<<<<<<<<<<
 *     unsigned char ucodeType
 *     unsigned int major
*/
struct nvmlNvlinkFirmwareVersion_t {
  unsigned char ucodeType;
  unsigned int major;
  unsigned int minor;
  unsigned int subMinor;
};

/* "cy_nvml.pxd":1277
 *     unsigned int subMinor
 * 
 * ctypedef union _anon_pod7 '_anon_pod7':             # <<<<<<<<<<<<<<
 *     unsigned char inData[496]
 *     unsigned char outData[496]
*/
union _anon_pod7 {
  unsigned char inData[496];
  unsigned char outData[496];
};

/* "cy_nvml.pxd":1281
 *     unsigned char outData[496]
 * 
 * ctypedef nvmlPciInfoExt_v1_t nvmlPciInfoExt_t 'nvmlPciInfoExt_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlCoolerInfo_v1_t nvmlCoolerInfo_t 'nvmlCoolerInfo_t'
 * ctypedef nvmlDramEncryptionInfo_v1_t nvmlDramEncryptionInfo_t 'nvmlDramEncryptionInfo_t'
*/
typedef nvmlPciInfoExt_v1_t nvmlPciInfoExt_t;

/* "cy_nvml.pxd":1282
 * 
 * ctypedef nvmlPciInfoExt_v1_t nvmlPciInfoExt_t 'nvmlPciInfoExt_t'
 * ctypedef nvmlCoolerInfo_v1_t nvmlCoolerInfo_t 'nvmlCoolerInfo_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlDramEncryptionInfo_v1_t nvmlDramEncryptionInfo_t 'nvmlDramEncryptionInfo_t'
 * ctypedef nvmlMarginTemperature_v1_t nvmlMarginTemperature_t 'nvmlMarginTemperature_t'
*/
typedef nvmlCoolerInfo_v1_t nvmlCoolerInfo_t;

/* "cy_nvml.pxd":1283
 * ctypedef nvmlPciInfoExt_v1_t nvmlPciInfoExt_t 'nvmlPciInfoExt_t'
 * ctypedef nvmlCoolerInfo_v1_t nvmlCoolerInfo_t 'nvmlCoolerInfo_t'
 * ctypedef nvmlDramEncryptionInfo_v1_t nvmlDramEncryptionInfo_t 'nvmlDramEncryptionInfo_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlMarginTemperature_v1_t nvmlMarginTemperature_t 'nvmlMarginTemperature_t'
 * ctypedef nvmlClockOffset_v1_t nvmlClockOffset_t 'nvmlClockOffset_t'
*/
typedef nvmlDramEncryptionInfo_v1_t nvmlDramEncryptionInfo_t;

/* "cy_nvml.pxd":1284
 * ctypedef nvmlCoolerInfo_v1_t nvmlCoolerInfo_t 'nvmlCoolerInfo_t'
 * ctypedef nvmlDramEncryptionInfo_v1_t nvmlDramEncryptionInfo_t 'nvmlDramEncryptionInfo_t'
 * ctypedef nvmlMarginTemperature_v1_t nvmlMarginTemperature_t 'nvmlMarginTemperature_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlClockOffset_v1_t nvmlClockOffset_t 'nvmlClockOffset_t'
 * ctypedef nvmlFanSpeedInfo_v1_t nvmlFanSpeedInfo_t 'nvmlFanSpeedInfo_t'
*/
typedef nvmlMarginTemperature_v1_t nvmlMarginTemperature_t;

/* "cy_nvml.pxd":1285
 * ctypedef nvmlDramEncryptionInfo_v1_t nvmlDramEncryptionInfo_t 'nvmlDramEncryptionInfo_t'
 * ctypedef nvmlMarginTemperature_v1_t nvmlMarginTemperature_t 'nvmlMarginTemperature_t'
 * ctypedef nvmlClockOffset_v1_t nvmlClockOffset_t 'nvmlClockOffset_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlFanSpeedInfo_v1_t nvmlFanSpeedInfo_t 'nvmlFanSpeedInfo_t'
 * ctypedef nvmlDevicePerfModes_v1_t nvmlDevicePerfModes_t 'nvmlDevicePerfModes_t'
*/
typedef nvmlClockOffset_v1_t nvmlClockOffset_t;

/* "cy_nvml.pxd":1286
 * ctypedef nvmlMarginTemperature_v1_t nvmlMarginTemperature_t 'nvmlMarginTemperature_t'
 * ctypedef nvmlClockOffset_v1_t nvmlClockOffset_t 'nvmlClockOffset_t'
 * ctypedef nvmlFanSpeedInfo_v1_t nvmlFanSpeedInfo_t 'nvmlFanSpeedInfo_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlDevicePerfModes_v1_t nvmlDevicePerfModes_t 'nvmlDevicePerfModes_t'
 * ctypedef nvmlDeviceCurrentClockFreqs_v1_t nvmlDeviceCurrentClockFreqs_t 'nvmlDeviceCurrentClockFreqs_t'
*/
typedef nvmlFanSpeedInfo_v1_t nvmlFanSpeedInfo_t;

/* "cy_nvml.pxd":1287
 * ctypedef nvmlClockOffset_v1_t nvmlClockOffset_t 'nvmlClockOffset_t'
 * ctypedef nvmlFanSpeedInfo_v1_t nvmlFanSpeedInfo_t 'nvmlFanSpeedInfo_t'
 * ctypedef nvmlDevicePerfModes_v1_t nvmlDevicePerfModes_t 'nvmlDevicePerfModes_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlDeviceCurrentClockFreqs_v1_t nvmlDeviceCurrentClockFreqs_t 'nvmlDeviceCurrentClockFreqs_t'
 * ctypedef nvmlEccSramErrorStatus_v1_t nvmlEccSramErrorStatus_t 'nvmlEccSramErrorStatus_t'
*/
typedef nvmlDevicePerfModes_v1_t nvmlDevicePerfModes_t;

/* "cy_nvml.pxd":1288
 * ctypedef nvmlFanSpeedInfo_v1_t nvmlFanSpeedInfo_t 'nvmlFanSpeedInfo_t'
 * ctypedef nvmlDevicePerfModes_v1_t nvmlDevicePerfModes_t 'nvmlDevicePerfModes_t'
 * ctypedef nvmlDeviceCurrentClockFreqs_v1_t nvmlDeviceCurrentClockFreqs_t 'nvmlDeviceCurrentClockFreqs_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlEccSramErrorStatus_v1_t nvmlEccSramErrorStatus_t 'nvmlEccSramErrorStatus_t'
 * ctypedef nvmlPlatformInfo_v2_t nvmlPlatformInfo_t 'nvmlPlatformInfo_t'
*/
typedef nvmlDeviceCurrentClockFreqs_v1_t nvmlDeviceCurrentClockFreqs_t;

/* "cy_nvml.pxd":1289
 * ctypedef nvmlDevicePerfModes_v1_t nvmlDevicePerfModes_t 'nvmlDevicePerfModes_t'
 * ctypedef nvmlDeviceCurrentClockFreqs_v1_t nvmlDeviceCurrentClockFreqs_t 'nvmlDeviceCurrentClockFreqs_t'
 * ctypedef nvmlEccSramErrorStatus_v1_t nvmlEccSramErrorStatus_t 'nvmlEccSramErrorStatus_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlPlatformInfo_v2_t nvmlPlatformInfo_t 'nvmlPlatformInfo_t'
 * ctypedef struct nvmlPowerValue_v2_t 'nvmlPowerValue_v2_t':
*/
typedef nvmlEccSramErrorStatus_v1_t nvmlEccSramErrorStatus_t;

/* "cy_nvml.pxd":1290
 * ctypedef nvmlDeviceCurrentClockFreqs_v1_t nvmlDeviceCurrentClockFreqs_t 'nvmlDeviceCurrentClockFreqs_t'
 * ctypedef nvmlEccSramErrorStatus_v1_t nvmlEccSramErrorStatus_t 'nvmlEccSramErrorStatus_t'
 * ctypedef nvmlPlatformInfo_v2_t nvmlPlatformInfo_t 'nvmlPlatformInfo_t'             # <<<<<<<<<<<<<<
 * ctypedef struct nvmlPowerValue_v2_t 'nvmlPowerValue_v2_t':
 *     unsigned int version
*/
typedef nvmlPlatformInfo_v2_t nvmlPlatformInfo_t;

/* "cy_nvml.pxd":1291
 * ctypedef nvmlEccSramErrorStatus_v1_t nvmlEccSramErrorStatus_t 'nvmlEccSramErrorStatus_t'
 * ctypedef nvmlPlatformInfo_v2_t nvmlPlatformInfo_t 'nvmlPlatformInfo_t'
 * ctypedef struct nvmlPowerValue_v2_t 'nvmlPowerValue_v2_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     nvmlPowerScopeType_t powerScope
*/
struct nvmlPowerValue_v2_t {
  unsigned int version;
  nvmlPowerScopeType_t powerScope;
  unsigned int powerValueMw;
};

/* "cy_nvml.pxd":1296
 *     unsigned int powerValueMw
 * 
 * ctypedef struct nvmlVgpuTypeIdInfo_v1_t 'nvmlVgpuTypeIdInfo_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int vgpuCount
*/
struct nvmlVgpuTypeIdInfo_v1_t {
  unsigned int version;
  unsigned int vgpuCount;
  nvmlVgpuTypeId_t *vgpuTypeIds;
};

/* "cy_nvml.pxd":1301
 *     nvmlVgpuTypeId_t* vgpuTypeIds
 * 
 * ctypedef struct nvmlVgpuTypeMaxInstance_v1_t 'nvmlVgpuTypeMaxInstance_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     nvmlVgpuTypeId_t vgpuTypeId
*/
struct nvmlVgpuTypeMaxInstance_v1_t {
  unsigned int version;
  nvmlVgpuTypeId_t vgpuTypeId;
  unsigned int maxInstancePerGI;
};

/* "cy_nvml.pxd":1306
 *     unsigned int maxInstancePerGI
 * 
 * ctypedef struct nvmlVgpuCreatablePlacementInfo_v1_t 'nvmlVgpuCreatablePlacementInfo_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     nvmlVgpuTypeId_t vgpuTypeId
*/
struct nvmlVgpuCreatablePlacementInfo_v1_t {
  unsigned int version;
  nvmlVgpuTypeId_t vgpuTypeId;
  unsigned int count;
  unsigned int *placementIds;
  unsigned int placementSize;
};

/* "cy_nvml.pxd":1313
 *     unsigned int placementSize
 * 
 * ctypedef struct nvmlVgpuProcessUtilizationSample_t 'nvmlVgpuProcessUtilizationSample_t':             # <<<<<<<<<<<<<<
 *     nvmlVgpuInstance_t vgpuInstance
 *     unsigned int pid
*/
struct nvmlVgpuProcessUtilizationSample_t {
  nvmlVgpuInstance_t vgpuInstance;
  unsigned int pid;
  char processName[64];
  unsigned PY_LONG_LONG timeStamp;
  unsigned int smUtil;
  unsigned int memUtil;
  unsigned int encUtil;
  unsigned int decUtil;
};

/* "cy_nvml.pxd":1323
 *     unsigned int decUtil
 * 
 * ctypedef struct nvmlVgpuProcessUtilizationInfo_v1_t 'nvmlVgpuProcessUtilizationInfo_v1_t':             # <<<<<<<<<<<<<<
 *     char processName[64]
 *     unsigned long long timeStamp
*/
struct nvmlVgpuProcessUtilizationInfo_v1_t {
  char processName[64];
  unsigned PY_LONG_LONG timeStamp;
  nvmlVgpuInstance_t vgpuInstance;
  unsigned int pid;
  unsigned int smUtil;
  unsigned int memUtil;
  unsigned int encUtil;
  unsigned int decUtil;
  unsigned int jpgUtil;
  unsigned int ofaUtil;
};

/* "cy_nvml.pxd":1335
 *     unsigned int ofaUtil
 * 
 * ctypedef struct nvmlActiveVgpuInstanceInfo_v1_t 'nvmlActiveVgpuInstanceInfo_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int vgpuCount
*/
struct nvmlActiveVgpuInstanceInfo_v1_t {
  unsigned int version;
  unsigned int vgpuCount;
  nvmlVgpuInstance_t *vgpuInstances;
};

/* "cy_nvml.pxd":1340
 *     nvmlVgpuInstance_t* vgpuInstances
 * 
 * ctypedef struct nvmlEncoderSessionInfo_t 'nvmlEncoderSessionInfo_t':             # <<<<<<<<<<<<<<
 *     unsigned int sessionId
 *     unsigned int pid
*/
struct nvmlEncoderSessionInfo_t {
  unsigned int sessionId;
  unsigned int pid;
  nvmlVgpuInstance_t vgpuInstance;
  nvmlEncoderType_t codecType;
  unsigned int hResolution;
  unsigned int vResolution;
  unsigned int averageFps;
  unsigned int averageLatency;
};

/* "cy_nvml.pxd":1350
 *     unsigned int averageLatency
 * 
 * ctypedef struct nvmlFBCSessionInfo_t 'nvmlFBCSessionInfo_t':             # <<<<<<<<<<<<<<
 *     unsigned int sessionId
 *     unsigned int pid
*/
struct nvmlFBCSessionInfo_t {
  unsigned int sessionId;
  unsigned int pid;
  nvmlVgpuInstance_t vgpuInstance;
  unsigned int displayOrdinal;
  nvmlFBCSessionType_t sessionType;
  unsigned int sessionFlags;
  unsigned int hMaxResolution;
  unsigned int vMaxResolution;
  unsigned int hResolution;
  unsigned int vResolution;
  unsigned int averageFPS;
  unsigned int averageLatency;
};

/* "cy_nvml.pxd":1364
 *     unsigned int averageLatency
 * 
 * ctypedef nvmlVgpuHeterogeneousMode_v1_t nvmlVgpuHeterogeneousMode_t 'nvmlVgpuHeterogeneousMode_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlVgpuPlacementId_v1_t nvmlVgpuPlacementId_t 'nvmlVgpuPlacementId_t'
 * ctypedef nvmlVgpuPlacementList_v2_t nvmlVgpuPlacementList_t 'nvmlVgpuPlacementList_t'
*/
typedef nvmlVgpuHeterogeneousMode_v1_t nvmlVgpuHeterogeneousMode_t;

/* "cy_nvml.pxd":1365
 * 
 * ctypedef nvmlVgpuHeterogeneousMode_v1_t nvmlVgpuHeterogeneousMode_t 'nvmlVgpuHeterogeneousMode_t'
 * ctypedef nvmlVgpuPlacementId_v1_t nvmlVgpuPlacementId_t 'nvmlVgpuPlacementId_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlVgpuPlacementList_v2_t nvmlVgpuPlacementList_t 'nvmlVgpuPlacementList_t'
 * ctypedef nvmlVgpuTypeBar1Info_v1_t nvmlVgpuTypeBar1Info_t 'nvmlVgpuTypeBar1Info_t'
*/
typedef nvmlVgpuPlacementId_v1_t nvmlVgpuPlacementId_t;

/* "cy_nvml.pxd":1366
 * ctypedef nvmlVgpuHeterogeneousMode_v1_t nvmlVgpuHeterogeneousMode_t 'nvmlVgpuHeterogeneousMode_t'
 * ctypedef nvmlVgpuPlacementId_v1_t nvmlVgpuPlacementId_t 'nvmlVgpuPlacementId_t'
 * ctypedef nvmlVgpuPlacementList_v2_t nvmlVgpuPlacementList_t 'nvmlVgpuPlacementList_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlVgpuTypeBar1Info_v1_t nvmlVgpuTypeBar1Info_t 'nvmlVgpuTypeBar1Info_t'
 * ctypedef nvmlVgpuRuntimeState_v1_t nvmlVgpuRuntimeState_t 'nvmlVgpuRuntimeState_t'
*/
typedef nvmlVgpuPlacementList_v2_t nvmlVgpuPlacementList_t;

/* "cy_nvml.pxd":1367
 * ctypedef nvmlVgpuPlacementId_v1_t nvmlVgpuPlacementId_t 'nvmlVgpuPlacementId_t'
 * ctypedef nvmlVgpuPlacementList_v2_t nvmlVgpuPlacementList_t 'nvmlVgpuPlacementList_t'
 * ctypedef nvmlVgpuTypeBar1Info_v1_t nvmlVgpuTypeBar1Info_t 'nvmlVgpuTypeBar1Info_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlVgpuRuntimeState_v1_t nvmlVgpuRuntimeState_t 'nvmlVgpuRuntimeState_t'
 * ctypedef nvmlSystemConfComputeSettings_v1_t nvmlSystemConfComputeSettings_t 'nvmlSystemConfComputeSettings_t'
*/
typedef nvmlVgpuTypeBar1Info_v1_t nvmlVgpuTypeBar1Info_t;

/* "cy_nvml.pxd":1368
 * ctypedef nvmlVgpuPlacementList_v2_t nvmlVgpuPlacementList_t 'nvmlVgpuPlacementList_t'
 * ctypedef nvmlVgpuTypeBar1Info_v1_t nvmlVgpuTypeBar1Info_t 'nvmlVgpuTypeBar1Info_t'
 * ctypedef nvmlVgpuRuntimeState_v1_t nvmlVgpuRuntimeState_t 'nvmlVgpuRuntimeState_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlSystemConfComputeSettings_v1_t nvmlSystemConfComputeSettings_t 'nvmlSystemConfComputeSettings_t'
 * ctypedef nvmlConfComputeSetKeyRotationThresholdInfo_v1_t nvmlConfComputeSetKeyRotationThresholdInfo_t 'nvmlConfComputeSetKeyRotationThresholdInfo_t'
*/
typedef nvmlVgpuRuntimeState_v1_t nvmlVgpuRuntimeState_t;

/* "cy_nvml.pxd":1369
 * ctypedef nvmlVgpuTypeBar1Info_v1_t nvmlVgpuTypeBar1Info_t 'nvmlVgpuTypeBar1Info_t'
 * ctypedef nvmlVgpuRuntimeState_v1_t nvmlVgpuRuntimeState_t 'nvmlVgpuRuntimeState_t'
 * ctypedef nvmlSystemConfComputeSettings_v1_t nvmlSystemConfComputeSettings_t 'nvmlSystemConfComputeSettings_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlConfComputeSetKeyRotationThresholdInfo_v1_t nvmlConfComputeSetKeyRotationThresholdInfo_t 'nvmlConfComputeSetKeyRotationThresholdInfo_t'
 * ctypedef nvmlConfComputeGetKeyRotationThresholdInfo_v1_t nvmlConfComputeGetKeyRotationThresholdInfo_t 'nvmlConfComputeGetKeyRotationThresholdInfo_t'
*/
typedef nvmlSystemConfComputeSettings_v1_t nvmlSystemConfComputeSettings_t;

/* "cy_nvml.pxd":1370
 * ctypedef nvmlVgpuRuntimeState_v1_t nvmlVgpuRuntimeState_t 'nvmlVgpuRuntimeState_t'
 * ctypedef nvmlSystemConfComputeSettings_v1_t nvmlSystemConfComputeSettings_t 'nvmlSystemConfComputeSettings_t'
 * ctypedef nvmlConfComputeSetKeyRotationThresholdInfo_v1_t nvmlConfComputeSetKeyRotationThresholdInfo_t 'nvmlConfComputeSetKeyRotationThresholdInfo_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlConfComputeGetKeyRotationThresholdInfo_v1_t nvmlConfComputeGetKeyRotationThresholdInfo_t 'nvmlConfComputeGetKeyRotationThresholdInfo_t'
 * ctypedef struct nvmlGpuFabricInfo_t 'nvmlGpuFabricInfo_t':
*/
typedef nvmlConfComputeSetKeyRotationThresholdInfo_v1_t nvmlConfComputeSetKeyRotationThresholdInfo_t;

/* "cy_nvml.pxd":1371
 * ctypedef nvmlSystemConfComputeSettings_v1_t nvmlSystemConfComputeSettings_t 'nvmlSystemConfComputeSettings_t'
 * ctypedef nvmlConfComputeSetKeyRotationThresholdInfo_v1_t nvmlConfComputeSetKeyRotationThresholdInfo_t 'nvmlConfComputeSetKeyRotationThresholdInfo_t'
 * ctypedef nvmlConfComputeGetKeyRotationThresholdInfo_v1_t nvmlConfComputeGetKeyRotationThresholdInfo_t 'nvmlConfComputeGetKeyRotationThresholdInfo_t'             # <<<<<<<<<<<<<<
 * ctypedef struct nvmlGpuFabricInfo_t 'nvmlGpuFabricInfo_t':
 *     unsigned char clusterUuid[16]
*/
typedef nvmlConfComputeGetKeyRotationThresholdInfo_v1_t nvmlConfComputeGetKeyRotationThresholdInfo_t;

/* "cy_nvml.pxd":1372
 * ctypedef nvmlConfComputeSetKeyRotationThresholdInfo_v1_t nvmlConfComputeSetKeyRotationThresholdInfo_t 'nvmlConfComputeSetKeyRotationThresholdInfo_t'
 * ctypedef nvmlConfComputeGetKeyRotationThresholdInfo_v1_t nvmlConfComputeGetKeyRotationThresholdInfo_t 'nvmlConfComputeGetKeyRotationThresholdInfo_t'
 * ctypedef struct nvmlGpuFabricInfo_t 'nvmlGpuFabricInfo_t':             # <<<<<<<<<<<<<<
 *     unsigned char clusterUuid[16]
 *     nvmlReturn_t status
*/
struct nvmlGpuFabricInfo_t {
  unsigned char clusterUuid[16];
  nvmlReturn_t status;
  unsigned int cliqueId;
  nvmlGpuFabricState_t state;
};

/* "cy_nvml.pxd":1378
 *     nvmlGpuFabricState_t state
 * 
 * ctypedef struct nvmlGpuFabricInfo_v2_t 'nvmlGpuFabricInfo_v2_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned char clusterUuid[16]
*/
struct nvmlGpuFabricInfo_v2_t {
  unsigned int version;
  unsigned char clusterUuid[16];
  nvmlReturn_t status;
  unsigned int cliqueId;
  nvmlGpuFabricState_t state;
  unsigned int healthMask;
};

/* "cy_nvml.pxd":1386
 *     unsigned int healthMask
 * 
 * ctypedef struct nvmlGpuFabricInfo_v3_t 'nvmlGpuFabricInfo_v3_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned char clusterUuid[16]
*/
struct nvmlGpuFabricInfo_v3_t {
  unsigned int version;
  unsigned char clusterUuid[16];
  nvmlReturn_t status;
  unsigned int cliqueId;
  nvmlGpuFabricState_t state;
  unsigned int healthMask;
  unsigned char healthSummary;
};

/* "cy_nvml.pxd":1395
 *     unsigned char healthSummary
 * 
 * ctypedef nvmlSystemDriverBranchInfo_v1_t nvmlSystemDriverBranchInfo_t 'nvmlSystemDriverBranchInfo_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlTemperature_v1_t nvmlTemperature_t 'nvmlTemperature_t'
 * ctypedef nvmlNvlinkSupportedBwModes_v1_t nvmlNvlinkSupportedBwModes_t 'nvmlNvlinkSupportedBwModes_t'
*/
typedef nvmlSystemDriverBranchInfo_v1_t nvmlSystemDriverBranchInfo_t;

/* "cy_nvml.pxd":1396
 * 
 * ctypedef nvmlSystemDriverBranchInfo_v1_t nvmlSystemDriverBranchInfo_t 'nvmlSystemDriverBranchInfo_t'
 * ctypedef nvmlTemperature_v1_t nvmlTemperature_t 'nvmlTemperature_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlNvlinkSupportedBwModes_v1_t nvmlNvlinkSupportedBwModes_t 'nvmlNvlinkSupportedBwModes_t'
 * ctypedef nvmlNvlinkGetBwMode_v1_t nvmlNvlinkGetBwMode_t 'nvmlNvlinkGetBwMode_t'
*/
typedef nvmlTemperature_v1_t nvmlTemperature_t;

/* "cy_nvml.pxd":1397
 * ctypedef nvmlSystemDriverBranchInfo_v1_t nvmlSystemDriverBranchInfo_t 'nvmlSystemDriverBranchInfo_t'
 * ctypedef nvmlTemperature_v1_t nvmlTemperature_t 'nvmlTemperature_t'
 * ctypedef nvmlNvlinkSupportedBwModes_v1_t nvmlNvlinkSupportedBwModes_t 'nvmlNvlinkSupportedBwModes_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlNvlinkGetBwMode_v1_t nvmlNvlinkGetBwMode_t 'nvmlNvlinkGetBwMode_t'
 * ctypedef nvmlNvlinkSetBwMode_v1_t nvmlNvlinkSetBwMode_t 'nvmlNvlinkSetBwMode_t'
*/
typedef nvmlNvlinkSupportedBwModes_v1_t nvmlNvlinkSupportedBwModes_t;

/* "cy_nvml.pxd":1398
 * ctypedef nvmlTemperature_v1_t nvmlTemperature_t 'nvmlTemperature_t'
 * ctypedef nvmlNvlinkSupportedBwModes_v1_t nvmlNvlinkSupportedBwModes_t 'nvmlNvlinkSupportedBwModes_t'
 * ctypedef nvmlNvlinkGetBwMode_v1_t nvmlNvlinkGetBwMode_t 'nvmlNvlinkGetBwMode_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlNvlinkSetBwMode_v1_t nvmlNvlinkSetBwMode_t 'nvmlNvlinkSetBwMode_t'
 * ctypedef nvmlDeviceCapabilities_v1_t nvmlDeviceCapabilities_t 'nvmlDeviceCapabilities_t'
*/
typedef nvmlNvlinkGetBwMode_v1_t nvmlNvlinkGetBwMode_t;

/* "cy_nvml.pxd":1399
 * ctypedef nvmlNvlinkSupportedBwModes_v1_t nvmlNvlinkSupportedBwModes_t 'nvmlNvlinkSupportedBwModes_t'
 * ctypedef nvmlNvlinkGetBwMode_v1_t nvmlNvlinkGetBwMode_t 'nvmlNvlinkGetBwMode_t'
 * ctypedef nvmlNvlinkSetBwMode_v1_t nvmlNvlinkSetBwMode_t 'nvmlNvlinkSetBwMode_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlDeviceCapabilities_v1_t nvmlDeviceCapabilities_t 'nvmlDeviceCapabilities_t'
 * ctypedef nvmlPowerSmoothingProfile_v1_t nvmlPowerSmoothingProfile_t 'nvmlPowerSmoothingProfile_t'
*/
typedef nvmlNvlinkSetBwMode_v1_t nvmlNvlinkSetBwMode_t;

/* "cy_nvml.pxd":1400
 * ctypedef nvmlNvlinkGetBwMode_v1_t nvmlNvlinkGetBwMode_t 'nvmlNvlinkGetBwMode_t'
 * ctypedef nvmlNvlinkSetBwMode_v1_t nvmlNvlinkSetBwMode_t 'nvmlNvlinkSetBwMode_t'
 * ctypedef nvmlDeviceCapabilities_v1_t nvmlDeviceCapabilities_t 'nvmlDeviceCapabilities_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlPowerSmoothingProfile_v1_t nvmlPowerSmoothingProfile_t 'nvmlPowerSmoothingProfile_t'
 * ctypedef nvmlPowerSmoothingState_v1_t nvmlPowerSmoothingState_t 'nvmlPowerSmoothingState_t'
*/
typedef nvmlDeviceCapabilities_v1_t nvmlDeviceCapabilities_t;

/* "cy_nvml.pxd":1401
 * ctypedef nvmlNvlinkSetBwMode_v1_t nvmlNvlinkSetBwMode_t 'nvmlNvlinkSetBwMode_t'
 * ctypedef nvmlDeviceCapabilities_v1_t nvmlDeviceCapabilities_t 'nvmlDeviceCapabilities_t'
 * ctypedef nvmlPowerSmoothingProfile_v1_t nvmlPowerSmoothingProfile_t 'nvmlPowerSmoothingProfile_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlPowerSmoothingState_v1_t nvmlPowerSmoothingState_t 'nvmlPowerSmoothingState_t'
 * ctypedef nvmlDeviceAddressingMode_v1_t nvmlDeviceAddressingMode_t 'nvmlDeviceAddressingMode_t'
*/
typedef nvmlPowerSmoothingProfile_v1_t nvmlPowerSmoothingProfile_t;

/* "cy_nvml.pxd":1402
 * ctypedef nvmlDeviceCapabilities_v1_t nvmlDeviceCapabilities_t 'nvmlDeviceCapabilities_t'
 * ctypedef nvmlPowerSmoothingProfile_v1_t nvmlPowerSmoothingProfile_t 'nvmlPowerSmoothingProfile_t'
 * ctypedef nvmlPowerSmoothingState_v1_t nvmlPowerSmoothingState_t 'nvmlPowerSmoothingState_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlDeviceAddressingMode_v1_t nvmlDeviceAddressingMode_t 'nvmlDeviceAddressingMode_t'
 * ctypedef nvmlRepairStatus_v1_t nvmlRepairStatus_t 'nvmlRepairStatus_t'
*/
typedef nvmlPowerSmoothingState_v1_t nvmlPowerSmoothingState_t;

/* "cy_nvml.pxd":1403
 * ctypedef nvmlPowerSmoothingProfile_v1_t nvmlPowerSmoothingProfile_t 'nvmlPowerSmoothingProfile_t'
 * ctypedef nvmlPowerSmoothingState_v1_t nvmlPowerSmoothingState_t 'nvmlPowerSmoothingState_t'
 * ctypedef nvmlDeviceAddressingMode_v1_t nvmlDeviceAddressingMode_t 'nvmlDeviceAddressingMode_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlRepairStatus_v1_t nvmlRepairStatus_t 'nvmlRepairStatus_t'
 * ctypedef nvmlPdi_v1_t nvmlPdi_t 'nvmlPdi_t'
*/
typedef nvmlDeviceAddressingMode_v1_t nvmlDeviceAddressingMode_t;

/* "cy_nvml.pxd":1404
 * ctypedef nvmlPowerSmoothingState_v1_t nvmlPowerSmoothingState_t 'nvmlPowerSmoothingState_t'
 * ctypedef nvmlDeviceAddressingMode_v1_t nvmlDeviceAddressingMode_t 'nvmlDeviceAddressingMode_t'
 * ctypedef nvmlRepairStatus_v1_t nvmlRepairStatus_t 'nvmlRepairStatus_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlPdi_v1_t nvmlPdi_t 'nvmlPdi_t'
 * ctypedef struct nvmlEventData_t 'nvmlEventData_t':
*/
typedef nvmlRepairStatus_v1_t nvmlRepairStatus_t;

/* "cy_nvml.pxd":1405
 * ctypedef nvmlDeviceAddressingMode_v1_t nvmlDeviceAddressingMode_t 'nvmlDeviceAddressingMode_t'
 * ctypedef nvmlRepairStatus_v1_t nvmlRepairStatus_t 'nvmlRepairStatus_t'
 * ctypedef nvmlPdi_v1_t nvmlPdi_t 'nvmlPdi_t'             # <<<<<<<<<<<<<<
 * ctypedef struct nvmlEventData_t 'nvmlEventData_t':
 *     nvmlDevice_t device
*/
typedef nvmlPdi_v1_t nvmlPdi_t;

/* "cy_nvml.pxd":1406
 * ctypedef nvmlRepairStatus_v1_t nvmlRepairStatus_t 'nvmlRepairStatus_t'
 * ctypedef nvmlPdi_v1_t nvmlPdi_t 'nvmlPdi_t'
 * ctypedef struct nvmlEventData_t 'nvmlEventData_t':             # <<<<<<<<<<<<<<
 *     nvmlDevice_t device
 *     unsigned long long eventType
*/
struct nvmlEventData_t {
  nvmlDevice_t device;
  unsigned PY_LONG_LONG eventType;
  unsigned PY_LONG_LONG eventData;
  unsigned int gpuInstanceId;
  unsigned int computeInstanceId;
};

/* "cy_nvml.pxd":1413
 *     unsigned int computeInstanceId
 * 
 * ctypedef struct nvmlSystemEventSetCreateRequest_v1_t 'nvmlSystemEventSetCreateRequest_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     nvmlSystemEventSet_t set
*/
struct nvmlSystemEventSetCreateRequest_v1_t {
  unsigned int version;
  nvmlSystemEventSet_t set;
};

/* "cy_nvml.pxd":1417
 *     nvmlSystemEventSet_t set
 * 
 * ctypedef struct nvmlSystemEventSetFreeRequest_v1_t 'nvmlSystemEventSetFreeRequest_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     nvmlSystemEventSet_t set
*/
struct nvmlSystemEventSetFreeRequest_v1_t {
  unsigned int version;
  nvmlSystemEventSet_t set;
};

/* "cy_nvml.pxd":1421
 *     nvmlSystemEventSet_t set
 * 
 * ctypedef struct nvmlSystemRegisterEventRequest_v1_t 'nvmlSystemRegisterEventRequest_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned long long eventTypes
*/
struct nvmlSystemRegisterEventRequest_v1_t {
  unsigned int version;
  unsigned PY_LONG_LONG eventTypes;
  nvmlSystemEventSet_t set;
};

/* "cy_nvml.pxd":1426
 *     nvmlSystemEventSet_t set
 * 
 * ctypedef struct nvmlExcludedDeviceInfo_t 'nvmlExcludedDeviceInfo_t':             # <<<<<<<<<<<<<<
 *     nvmlPciInfo_t pciInfo
 *     char uuid[80]
*/
struct nvmlExcludedDeviceInfo_t {
  nvmlPciInfo_t pciInfo;
  char uuid[80];
};

/* "cy_nvml.pxd":1430
 *     char uuid[80]
 * 
 * ctypedef struct nvmlProcessDetailList_v1_t 'nvmlProcessDetailList_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int mode
*/
struct nvmlProcessDetailList_v1_t {
  unsigned int version;
  unsigned int mode;
  unsigned int numProcArrayEntries;
  nvmlProcessDetail_v1_t *procArray;
};

/* "cy_nvml.pxd":1436
 *     nvmlProcessDetail_v1_t* procArray
 * 
 * ctypedef struct nvmlBridgeChipHierarchy_t 'nvmlBridgeChipHierarchy_t':             # <<<<<<<<<<<<<<
 *     unsigned char bridgeCount
 *     nvmlBridgeChipInfo_t bridgeChipInfo[128]
*/
struct nvmlBridgeChipHierarchy_t {
  unsigned char bridgeCount;
  nvmlBridgeChipInfo_t bridgeChipInfo[128];
};

/* "cy_nvml.pxd":1440
 *     nvmlBridgeChipInfo_t bridgeChipInfo[128]
 * 
 * ctypedef struct nvmlSample_t 'nvmlSample_t':             # <<<<<<<<<<<<<<
 *     unsigned long long timeStamp
 *     nvmlValue_t sampleValue
*/
struct nvmlSample_t {
  unsigned PY_LONG_LONG timeStamp;
  nvmlValue_t sampleValue;
};

/* "cy_nvml.pxd":1444
 *     nvmlValue_t sampleValue
 * 
 * ctypedef struct nvmlVgpuInstanceUtilizationSample_t 'nvmlVgpuInstanceUtilizationSample_t':             # <<<<<<<<<<<<<<
 *     nvmlVgpuInstance_t vgpuInstance
 *     unsigned long long timeStamp
*/
struct nvmlVgpuInstanceUtilizationSample_t {
  nvmlVgpuInstance_t vgpuInstance;
  unsigned PY_LONG_LONG timeStamp;
  nvmlValue_t smUtil;
  nvmlValue_t memUtil;
  nvmlValue_t encUtil;
  nvmlValue_t decUtil;
};

/* "cy_nvml.pxd":1452
 *     nvmlValue_t decUtil
 * 
 * ctypedef struct nvmlVgpuInstanceUtilizationInfo_v1_t 'nvmlVgpuInstanceUtilizationInfo_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned long long timeStamp
 *     nvmlVgpuInstance_t vgpuInstance
*/
struct nvmlVgpuInstanceUtilizationInfo_v1_t {
  unsigned PY_LONG_LONG timeStamp;
  nvmlVgpuInstance_t vgpuInstance;
  nvmlValue_t smUtil;
  nvmlValue_t memUtil;
  nvmlValue_t encUtil;
  nvmlValue_t decUtil;
  nvmlValue_t jpgUtil;
  nvmlValue_t ofaUtil;
};

/* "cy_nvml.pxd":1462
 *     nvmlValue_t ofaUtil
 * 
 * ctypedef struct nvmlFieldValue_t 'nvmlFieldValue_t':             # <<<<<<<<<<<<<<
 *     unsigned int fieldId
 *     unsigned int scopeId
*/
struct nvmlFieldValue_t {
  unsigned int fieldId;
  unsigned int scopeId;
  PY_LONG_LONG timestamp;
  PY_LONG_LONG latencyUsec;
  nvmlValueType_t valueType;
  nvmlReturn_t nvmlReturn;
  nvmlValue_t value;
};

/* "cy_nvml.pxd":1471
 *     nvmlValue_t value
 * 
 * ctypedef struct nvmlGpuThermalSettings_t 'nvmlGpuThermalSettings_t':             # <<<<<<<<<<<<<<
 *     unsigned int count
 *     _anon_pod0 sensor[3]
*/
struct nvmlGpuThermalSettings_t {
  unsigned int count;
  _anon_pod0 sensor[3];
};

/* "cy_nvml.pxd":1475
 *     _anon_pod0 sensor[3]
 * 
 * ctypedef struct nvmlUUID_v1_t 'nvmlUUID_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int type
*/
struct nvmlUUID_v1_t {
  unsigned int version;
  unsigned int type;
  nvmlUUIDValue_t value;
};

/* "cy_nvml.pxd":1480
 *     nvmlUUIDValue_t value
 * 
 * ctypedef struct nvmlClkMonStatus_t 'nvmlClkMonStatus_t':             # <<<<<<<<<<<<<<
 *     unsigned int bGlobalStatus
 *     unsigned int clkMonListSize
*/
struct nvmlClkMonStatus_t {
  unsigned int bGlobalStatus;
  unsigned int clkMonListSize;
  nvmlClkMonFaultInfo_t clkMonList[32];
};

/* "cy_nvml.pxd":1485
 *     nvmlClkMonFaultInfo_t clkMonList[32]
 * 
 * ctypedef struct nvmlProcessesUtilizationInfo_v1_t 'nvmlProcessesUtilizationInfo_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int processSamplesCount
*/
struct nvmlProcessesUtilizationInfo_v1_t {
  unsigned int version;
  unsigned int processSamplesCount;
  unsigned PY_LONG_LONG lastSeenTimeStamp;
  nvmlProcessUtilizationInfo_v1_t *procUtilArray;
};

/* "cy_nvml.pxd":1491
 *     nvmlProcessUtilizationInfo_v1_t* procUtilArray
 * 
 * ctypedef struct nvmlGpuDynamicPstatesInfo_t 'nvmlGpuDynamicPstatesInfo_t':             # <<<<<<<<<<<<<<
 *     unsigned int flags
 *     _anon_pod1 utilization[8]
*/
struct nvmlGpuDynamicPstatesInfo_t {
  unsigned int flags;
  _anon_pod1 utilization[8];
};

/* "cy_nvml.pxd":1495
 *     _anon_pod1 utilization[8]
 * 
 * ctypedef union nvmlVgpuSchedulerParams_t 'nvmlVgpuSchedulerParams_t':             # <<<<<<<<<<<<<<
 *     _anon_pod2 vgpuSchedDataWithARR
 *     _anon_pod3 vgpuSchedData
*/
union nvmlVgpuSchedulerParams_t {
  _anon_pod2 vgpuSchedDataWithARR;
  _anon_pod3 vgpuSchedData;
};

/* "cy_nvml.pxd":1499
 *     _anon_pod3 vgpuSchedData
 * 
 * ctypedef union nvmlVgpuSchedulerSetParams_t 'nvmlVgpuSchedulerSetParams_t':             # <<<<<<<<<<<<<<
 *     _anon_pod4 vgpuSchedDataWithARR
 *     _anon_pod5 vgpuSchedData
*/
union nvmlVgpuSchedulerSetParams_t {
  _anon_pod4 vgpuSchedDataWithARR;
  _anon_pod5 vgpuSchedData;
};

/* "cy_nvml.pxd":1503
 *     _anon_pod5 vgpuSchedData
 * 
 * ctypedef struct nvmlVgpuLicenseInfo_t 'nvmlVgpuLicenseInfo_t':             # <<<<<<<<<<<<<<
 *     unsigned char isLicensed
 *     nvmlVgpuLicenseExpiry_t licenseExpiry
*/
struct nvmlVgpuLicenseInfo_t {
  unsigned char isLicensed;
  nvmlVgpuLicenseExpiry_t licenseExpiry;
  unsigned int currentState;
};

/* "cy_nvml.pxd":1508
 *     unsigned int currentState
 * 
 * ctypedef struct nvmlGridLicensableFeature_t 'nvmlGridLicensableFeature_t':             # <<<<<<<<<<<<<<
 *     nvmlGridLicenseFeatureCode_t featureCode
 *     unsigned int featureState
*/
struct nvmlGridLicensableFeature_t {
  nvmlGridLicenseFeatureCode_t featureCode;
  unsigned int featureState;
  char licenseInfo[128];
  char productName[128];
  unsigned int featureEnabled;
  nvmlGridLicenseExpiry_t licenseExpiry;
};

/* "cy_nvml.pxd":1516
 *     nvmlGridLicenseExpiry_t licenseExpiry
 * 
 * ctypedef struct nvmlUnitFanSpeeds_t 'nvmlUnitFanSpeeds_t':             # <<<<<<<<<<<<<<
 *     nvmlUnitFanInfo_t fans[24]
 *     unsigned int count
*/
struct nvmlUnitFanSpeeds_t {
  nvmlUnitFanInfo_t fans[24];
  unsigned int count;
};

/* "cy_nvml.pxd":1520
 *     unsigned int count
 * 
 * ctypedef struct nvmlSystemEventSetWaitRequest_v1_t 'nvmlSystemEventSetWaitRequest_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int timeoutms
*/
struct nvmlSystemEventSetWaitRequest_v1_t {
  unsigned int version;
  unsigned int timeoutms;
  nvmlSystemEventSet_t set;
  nvmlSystemEventData_v1_t *data;
  unsigned int dataSize;
  unsigned int numEvent;
};

/* "cy_nvml.pxd":1528
 *     unsigned int numEvent
 * 
 * ctypedef struct nvmlVgpuPgpuMetadata_t 'nvmlVgpuPgpuMetadata_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int revision
*/
struct nvmlVgpuPgpuMetadata_t {
  unsigned int version;
  unsigned int revision;
  char hostDriverVersion[80];
  unsigned int pgpuVirtualizationCaps;
  unsigned int reserved[5];
  nvmlVgpuVersion_t hostSupportedVgpuRange;
  unsigned int opaqueDataSize;
  char opaqueData[4];
};

/* "cy_nvml.pxd":1538
 *     char opaqueData[4]
 * 
 * ctypedef struct nvmlGpuInstanceInfo_t 'nvmlGpuInstanceInfo_t':             # <<<<<<<<<<<<<<
 *     nvmlDevice_t device
 *     unsigned int id
*/
struct nvmlGpuInstanceInfo_t {
  nvmlDevice_t device;
  unsigned int id;
  unsigned int profileId;
  nvmlGpuInstancePlacement_t placement;
};

/* "cy_nvml.pxd":1544
 *     nvmlGpuInstancePlacement_t placement
 * 
 * ctypedef struct nvmlComputeInstanceInfo_t 'nvmlComputeInstanceInfo_t':             # <<<<<<<<<<<<<<
 *     nvmlDevice_t device
 *     nvmlGpuInstance_t gpuInstance
*/
struct nvmlComputeInstanceInfo_t {
  nvmlDevice_t device;
  nvmlGpuInstance_t gpuInstance;
  unsigned int id;
  unsigned int profileId;
  nvmlComputeInstancePlacement_t placement;
};

/* "cy_nvml.pxd":1551
 *     nvmlComputeInstancePlacement_t placement
 * 
 * ctypedef struct nvmlGpmMetric_t 'nvmlGpmMetric_t':             # <<<<<<<<<<<<<<
 *     unsigned int metricId
 *     nvmlReturn_t nvmlReturn
*/
struct nvmlGpmMetric_t {
  unsigned int metricId;
  nvmlReturn_t nvmlReturn;
  double value;
  _anon_pod6 metricInfo;
};

/* "cy_nvml.pxd":1557
 *     _anon_pod6 metricInfo
 * 
 * ctypedef struct nvmlWorkloadPowerProfileInfo_v1_t 'nvmlWorkloadPowerProfileInfo_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int profileId
*/
struct nvmlWorkloadPowerProfileInfo_v1_t {
  unsigned int version;
  unsigned int profileId;
  unsigned int priority;
  nvmlMask255_t conflictingMask;
};

/* "cy_nvml.pxd":1563
 *     nvmlMask255_t conflictingMask
 * 
 * ctypedef struct nvmlWorkloadPowerProfileCurrentProfiles_v1_t 'nvmlWorkloadPowerProfileCurrentProfiles_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     nvmlMask255_t perfProfilesMask
*/
struct nvmlWorkloadPowerProfileCurrentProfiles_v1_t {
  unsigned int version;
  nvmlMask255_t perfProfilesMask;
  nvmlMask255_t requestedProfilesMask;
  nvmlMask255_t enforcedProfilesMask;
};

/* "cy_nvml.pxd":1569
 *     nvmlMask255_t enforcedProfilesMask
 * 
 * ctypedef struct nvmlWorkloadPowerProfileRequestedProfiles_v1_t 'nvmlWorkloadPowerProfileRequestedProfiles_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     nvmlMask255_t requestedProfilesMask
*/
struct nvmlWorkloadPowerProfileRequestedProfiles_v1_t {
  unsigned int version;
  nvmlMask255_t requestedProfilesMask;
};

/* "cy_nvml.pxd":1573
 *     nvmlMask255_t requestedProfilesMask
 * 
 * ctypedef struct nvmlEccSramUniqueUncorrectedErrorCounts_v1_t 'nvmlEccSramUniqueUncorrectedErrorCounts_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int entryCount
*/
struct nvmlEccSramUniqueUncorrectedErrorCounts_v1_t {
  unsigned int version;
  unsigned int entryCount;
  nvmlEccSramUniqueUncorrectedErrorEntry_v1_t *entries;
};

/* "cy_nvml.pxd":1578
 *     nvmlEccSramUniqueUncorrectedErrorEntry_v1_t* entries
 * 
 * ctypedef struct nvmlNvlinkFirmwareInfo_t 'nvmlNvlinkFirmwareInfo_t':             # <<<<<<<<<<<<<<
 *     nvmlNvlinkFirmwareVersion_t firmwareVersion[100]
 *     unsigned int numValidEntries
*/
struct nvmlNvlinkFirmwareInfo_t {
  nvmlNvlinkFirmwareVersion_t firmwareVersion[100];
  unsigned int numValidEntries;
};

/* "cy_nvml.pxd":1582
 *     unsigned int numValidEntries
 * 
 * ctypedef struct nvmlPRMTLV_v1_t 'nvmlPRMTLV_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned dataSize
 *     unsigned status
*/
struct nvmlPRMTLV_v1_t {
  unsigned int dataSize;
  unsigned int status;
  _anon_pod7 _anon_pod_member0;
};

/* "cy_nvml.pxd":1587
 *     _anon_pod7 _anon_pod_member0
 * 
 * ctypedef nvmlVgpuTypeIdInfo_v1_t nvmlVgpuTypeIdInfo_t 'nvmlVgpuTypeIdInfo_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlVgpuTypeMaxInstance_v1_t nvmlVgpuTypeMaxInstance_t 'nvmlVgpuTypeMaxInstance_t'
 * ctypedef nvmlVgpuCreatablePlacementInfo_v1_t nvmlVgpuCreatablePlacementInfo_t 'nvmlVgpuCreatablePlacementInfo_t'
*/
typedef nvmlVgpuTypeIdInfo_v1_t nvmlVgpuTypeIdInfo_t;

/* "cy_nvml.pxd":1588
 * 
 * ctypedef nvmlVgpuTypeIdInfo_v1_t nvmlVgpuTypeIdInfo_t 'nvmlVgpuTypeIdInfo_t'
 * ctypedef nvmlVgpuTypeMaxInstance_v1_t nvmlVgpuTypeMaxInstance_t 'nvmlVgpuTypeMaxInstance_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlVgpuCreatablePlacementInfo_v1_t nvmlVgpuCreatablePlacementInfo_t 'nvmlVgpuCreatablePlacementInfo_t'
 * ctypedef struct nvmlVgpuProcessesUtilizationInfo_v1_t 'nvmlVgpuProcessesUtilizationInfo_v1_t':
*/
typedef nvmlVgpuTypeMaxInstance_v1_t nvmlVgpuTypeMaxInstance_t;

/* "cy_nvml.pxd":1589
 * ctypedef nvmlVgpuTypeIdInfo_v1_t nvmlVgpuTypeIdInfo_t 'nvmlVgpuTypeIdInfo_t'
 * ctypedef nvmlVgpuTypeMaxInstance_v1_t nvmlVgpuTypeMaxInstance_t 'nvmlVgpuTypeMaxInstance_t'
 * ctypedef nvmlVgpuCreatablePlacementInfo_v1_t nvmlVgpuCreatablePlacementInfo_t 'nvmlVgpuCreatablePlacementInfo_t'             # <<<<<<<<<<<<<<
 * ctypedef struct nvmlVgpuProcessesUtilizationInfo_v1_t 'nvmlVgpuProcessesUtilizationInfo_v1_t':
 *     unsigned int version
*/
typedef nvmlVgpuCreatablePlacementInfo_v1_t nvmlVgpuCreatablePlacementInfo_t;

/* "cy_nvml.pxd":1590
 * ctypedef nvmlVgpuTypeMaxInstance_v1_t nvmlVgpuTypeMaxInstance_t 'nvmlVgpuTypeMaxInstance_t'
 * ctypedef nvmlVgpuCreatablePlacementInfo_v1_t nvmlVgpuCreatablePlacementInfo_t 'nvmlVgpuCreatablePlacementInfo_t'
 * ctypedef struct nvmlVgpuProcessesUtilizationInfo_v1_t 'nvmlVgpuProcessesUtilizationInfo_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int vgpuProcessCount
*/
struct nvmlVgpuProcessesUtilizationInfo_v1_t {
  unsigned int version;
  unsigned int vgpuProcessCount;
  unsigned PY_LONG_LONG lastSeenTimeStamp;
  nvmlVgpuProcessUtilizationInfo_v1_t *vgpuProcUtilArray;
};

/* "cy_nvml.pxd":1596
 *     nvmlVgpuProcessUtilizationInfo_v1_t* vgpuProcUtilArray
 * 
 * ctypedef nvmlActiveVgpuInstanceInfo_v1_t nvmlActiveVgpuInstanceInfo_t 'nvmlActiveVgpuInstanceInfo_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlGpuFabricInfo_v3_t nvmlGpuFabricInfoV_t 'nvmlGpuFabricInfoV_t'
 * ctypedef nvmlSystemEventSetCreateRequest_v1_t nvmlSystemEventSetCreateRequest_t 'nvmlSystemEventSetCreateRequest_t'
*/
typedef nvmlActiveVgpuInstanceInfo_v1_t nvmlActiveVgpuInstanceInfo_t;

/* "cy_nvml.pxd":1597
 * 
 * ctypedef nvmlActiveVgpuInstanceInfo_v1_t nvmlActiveVgpuInstanceInfo_t 'nvmlActiveVgpuInstanceInfo_t'
 * ctypedef nvmlGpuFabricInfo_v3_t nvmlGpuFabricInfoV_t 'nvmlGpuFabricInfoV_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlSystemEventSetCreateRequest_v1_t nvmlSystemEventSetCreateRequest_t 'nvmlSystemEventSetCreateRequest_t'
 * ctypedef nvmlSystemEventSetFreeRequest_v1_t nvmlSystemEventSetFreeRequest_t 'nvmlSystemEventSetFreeRequest_t'
*/
typedef nvmlGpuFabricInfo_v3_t nvmlGpuFabricInfoV_t;

/* "cy_nvml.pxd":1598
 * ctypedef nvmlActiveVgpuInstanceInfo_v1_t nvmlActiveVgpuInstanceInfo_t 'nvmlActiveVgpuInstanceInfo_t'
 * ctypedef nvmlGpuFabricInfo_v3_t nvmlGpuFabricInfoV_t 'nvmlGpuFabricInfoV_t'
 * ctypedef nvmlSystemEventSetCreateRequest_v1_t nvmlSystemEventSetCreateRequest_t 'nvmlSystemEventSetCreateRequest_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlSystemEventSetFreeRequest_v1_t nvmlSystemEventSetFreeRequest_t 'nvmlSystemEventSetFreeRequest_t'
 * ctypedef nvmlSystemRegisterEventRequest_v1_t nvmlSystemRegisterEventRequest_t 'nvmlSystemRegisterEventRequest_t'
*/
typedef nvmlSystemEventSetCreateRequest_v1_t nvmlSystemEventSetCreateRequest_t;

/* "cy_nvml.pxd":1599
 * ctypedef nvmlGpuFabricInfo_v3_t nvmlGpuFabricInfoV_t 'nvmlGpuFabricInfoV_t'
 * ctypedef nvmlSystemEventSetCreateRequest_v1_t nvmlSystemEventSetCreateRequest_t 'nvmlSystemEventSetCreateRequest_t'
 * ctypedef nvmlSystemEventSetFreeRequest_v1_t nvmlSystemEventSetFreeRequest_t 'nvmlSystemEventSetFreeRequest_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlSystemRegisterEventRequest_v1_t nvmlSystemRegisterEventRequest_t 'nvmlSystemRegisterEventRequest_t'
 * ctypedef nvmlProcessDetailList_v1_t nvmlProcessDetailList_t 'nvmlProcessDetailList_t'
*/
typedef nvmlSystemEventSetFreeRequest_v1_t nvmlSystemEventSetFreeRequest_t;

/* "cy_nvml.pxd":1600
 * ctypedef nvmlSystemEventSetCreateRequest_v1_t nvmlSystemEventSetCreateRequest_t 'nvmlSystemEventSetCreateRequest_t'
 * ctypedef nvmlSystemEventSetFreeRequest_v1_t nvmlSystemEventSetFreeRequest_t 'nvmlSystemEventSetFreeRequest_t'
 * ctypedef nvmlSystemRegisterEventRequest_v1_t nvmlSystemRegisterEventRequest_t 'nvmlSystemRegisterEventRequest_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlProcessDetailList_v1_t nvmlProcessDetailList_t 'nvmlProcessDetailList_t'
 * ctypedef struct nvmlVgpuInstancesUtilizationInfo_v1_t 'nvmlVgpuInstancesUtilizationInfo_v1_t':
*/
typedef nvmlSystemRegisterEventRequest_v1_t nvmlSystemRegisterEventRequest_t;

/* "cy_nvml.pxd":1601
 * ctypedef nvmlSystemEventSetFreeRequest_v1_t nvmlSystemEventSetFreeRequest_t 'nvmlSystemEventSetFreeRequest_t'
 * ctypedef nvmlSystemRegisterEventRequest_v1_t nvmlSystemRegisterEventRequest_t 'nvmlSystemRegisterEventRequest_t'
 * ctypedef nvmlProcessDetailList_v1_t nvmlProcessDetailList_t 'nvmlProcessDetailList_t'             # <<<<<<<<<<<<<<
 * ctypedef struct nvmlVgpuInstancesUtilizationInfo_v1_t 'nvmlVgpuInstancesUtilizationInfo_v1_t':
 *     unsigned int version
*/
typedef nvmlProcessDetailList_v1_t nvmlProcessDetailList_t;

/* "cy_nvml.pxd":1602
 * ctypedef nvmlSystemRegisterEventRequest_v1_t nvmlSystemRegisterEventRequest_t 'nvmlSystemRegisterEventRequest_t'
 * ctypedef nvmlProcessDetailList_v1_t nvmlProcessDetailList_t 'nvmlProcessDetailList_t'
 * ctypedef struct nvmlVgpuInstancesUtilizationInfo_v1_t 'nvmlVgpuInstancesUtilizationInfo_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     nvmlValueType_t sampleValType
*/
struct nvmlVgpuInstancesUtilizationInfo_v1_t {
  unsigned int version;
  nvmlValueType_t sampleValType;
  unsigned int vgpuInstanceCount;
  unsigned PY_LONG_LONG lastSeenTimeStamp;
  nvmlVgpuInstanceUtilizationInfo_v1_t *vgpuUtilArray;
};

/* "cy_nvml.pxd":1609
 *     nvmlVgpuInstanceUtilizationInfo_v1_t* vgpuUtilArray
 * 
 * ctypedef nvmlUUID_v1_t nvmlUUID_t 'nvmlUUID_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlProcessesUtilizationInfo_v1_t nvmlProcessesUtilizationInfo_t 'nvmlProcessesUtilizationInfo_t'
 * ctypedef struct nvmlVgpuSchedulerLog_t 'nvmlVgpuSchedulerLog_t':
*/
typedef nvmlUUID_v1_t nvmlUUID_t;

/* "cy_nvml.pxd":1610
 * 
 * ctypedef nvmlUUID_v1_t nvmlUUID_t 'nvmlUUID_t'
 * ctypedef nvmlProcessesUtilizationInfo_v1_t nvmlProcessesUtilizationInfo_t 'nvmlProcessesUtilizationInfo_t'             # <<<<<<<<<<<<<<
 * ctypedef struct nvmlVgpuSchedulerLog_t 'nvmlVgpuSchedulerLog_t':
 *     unsigned int engineId
*/
typedef nvmlProcessesUtilizationInfo_v1_t nvmlProcessesUtilizationInfo_t;

/* "cy_nvml.pxd":1611
 * ctypedef nvmlUUID_v1_t nvmlUUID_t 'nvmlUUID_t'
 * ctypedef nvmlProcessesUtilizationInfo_v1_t nvmlProcessesUtilizationInfo_t 'nvmlProcessesUtilizationInfo_t'
 * ctypedef struct nvmlVgpuSchedulerLog_t 'nvmlVgpuSchedulerLog_t':             # <<<<<<<<<<<<<<
 *     unsigned int engineId
 *     unsigned int schedulerPolicy
*/
struct nvmlVgpuSchedulerLog_t {
  unsigned int engineId;
  unsigned int schedulerPolicy;
  unsigned int arrMode;
  nvmlVgpuSchedulerParams_t schedulerParams;
  unsigned int entriesCount;
  nvmlVgpuSchedulerLogEntry_t logEntries[200];
};

/* "cy_nvml.pxd":1619
 *     nvmlVgpuSchedulerLogEntry_t logEntries[200]
 * 
 * ctypedef struct nvmlVgpuSchedulerGetState_t 'nvmlVgpuSchedulerGetState_t':             # <<<<<<<<<<<<<<
 *     unsigned int schedulerPolicy
 *     unsigned int arrMode
*/
struct nvmlVgpuSchedulerGetState_t {
  unsigned int schedulerPolicy;
  unsigned int arrMode;
  nvmlVgpuSchedulerParams_t schedulerParams;
};

/* "cy_nvml.pxd":1624
 *     nvmlVgpuSchedulerParams_t schedulerParams
 * 
 * ctypedef struct nvmlVgpuSchedulerStateInfo_v1_t 'nvmlVgpuSchedulerStateInfo_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int engineId
*/
struct nvmlVgpuSchedulerStateInfo_v1_t {
  unsigned int version;
  unsigned int engineId;
  unsigned int schedulerPolicy;
  unsigned int arrMode;
  nvmlVgpuSchedulerParams_t schedulerParams;
};

/* "cy_nvml.pxd":1631
 *     nvmlVgpuSchedulerParams_t schedulerParams
 * 
 * ctypedef struct nvmlVgpuSchedulerLogInfo_v1_t 'nvmlVgpuSchedulerLogInfo_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int engineId
*/
struct nvmlVgpuSchedulerLogInfo_v1_t {
  unsigned int version;
  unsigned int engineId;
  unsigned int schedulerPolicy;
  unsigned int arrMode;
  nvmlVgpuSchedulerParams_t schedulerParams;
  unsigned int entriesCount;
  nvmlVgpuSchedulerLogEntry_t logEntries[200];
};

/* "cy_nvml.pxd":1640
 *     nvmlVgpuSchedulerLogEntry_t logEntries[200]
 * 
 * ctypedef struct nvmlVgpuSchedulerSetState_t 'nvmlVgpuSchedulerSetState_t':             # <<<<<<<<<<<<<<
 *     unsigned int schedulerPolicy
 *     unsigned int enableARRMode
*/
struct nvmlVgpuSchedulerSetState_t {
  unsigned int schedulerPolicy;
  unsigned int enableARRMode;
  nvmlVgpuSchedulerSetParams_t schedulerParams;
};

/* "cy_nvml.pxd":1645
 *     nvmlVgpuSchedulerSetParams_t schedulerParams
 * 
 * ctypedef struct nvmlVgpuSchedulerState_v1_t 'nvmlVgpuSchedulerState_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int engineId
*/
struct nvmlVgpuSchedulerState_v1_t {
  unsigned int version;
  unsigned int engineId;
  unsigned int schedulerPolicy;
  unsigned int enableARRMode;
  nvmlVgpuSchedulerSetParams_t schedulerParams;
};

/* "cy_nvml.pxd":1652
 *     nvmlVgpuSchedulerSetParams_t schedulerParams
 * 
 * ctypedef struct nvmlGridLicensableFeatures_t 'nvmlGridLicensableFeatures_t':             # <<<<<<<<<<<<<<
 *     int isGridLicenseSupported
 *     unsigned int licensableFeaturesCount
*/
struct nvmlGridLicensableFeatures_t {
  int isGridLicenseSupported;
  unsigned int licensableFeaturesCount;
  nvmlGridLicensableFeature_t gridLicensableFeatures[3];
};

/* "cy_nvml.pxd":1657
 *     nvmlGridLicensableFeature_t gridLicensableFeatures[3]
 * 
 * ctypedef nvmlSystemEventSetWaitRequest_v1_t nvmlSystemEventSetWaitRequest_t 'nvmlSystemEventSetWaitRequest_t'             # <<<<<<<<<<<<<<
 * ctypedef struct nvmlGpmMetricsGet_t 'nvmlGpmMetricsGet_t':
 *     unsigned int version
*/
typedef nvmlSystemEventSetWaitRequest_v1_t nvmlSystemEventSetWaitRequest_t;

/* "cy_nvml.pxd":1658
 * 
 * ctypedef nvmlSystemEventSetWaitRequest_v1_t nvmlSystemEventSetWaitRequest_t 'nvmlSystemEventSetWaitRequest_t'
 * ctypedef struct nvmlGpmMetricsGet_t 'nvmlGpmMetricsGet_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int numMetrics
*/
struct nvmlGpmMetricsGet_t {
  unsigned int version;
  unsigned int numMetrics;
  nvmlGpmSample_t sample1;
  nvmlGpmSample_t sample2;
  nvmlGpmMetric_t metrics[210];
};

/* "cy_nvml.pxd":1665
 *     nvmlGpmMetric_t metrics[210]
 * 
 * ctypedef nvmlWorkloadPowerProfileInfo_v1_t nvmlWorkloadPowerProfileInfo_t 'nvmlWorkloadPowerProfileInfo_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlWorkloadPowerProfileCurrentProfiles_v1_t nvmlWorkloadPowerProfileCurrentProfiles_t 'nvmlWorkloadPowerProfileCurrentProfiles_t'
 * ctypedef nvmlWorkloadPowerProfileRequestedProfiles_v1_t nvmlWorkloadPowerProfileRequestedProfiles_t 'nvmlWorkloadPowerProfileRequestedProfiles_t'
*/
typedef nvmlWorkloadPowerProfileInfo_v1_t nvmlWorkloadPowerProfileInfo_t;

/* "cy_nvml.pxd":1666
 * 
 * ctypedef nvmlWorkloadPowerProfileInfo_v1_t nvmlWorkloadPowerProfileInfo_t 'nvmlWorkloadPowerProfileInfo_t'
 * ctypedef nvmlWorkloadPowerProfileCurrentProfiles_v1_t nvmlWorkloadPowerProfileCurrentProfiles_t 'nvmlWorkloadPowerProfileCurrentProfiles_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlWorkloadPowerProfileRequestedProfiles_v1_t nvmlWorkloadPowerProfileRequestedProfiles_t 'nvmlWorkloadPowerProfileRequestedProfiles_t'
 * ctypedef nvmlEccSramUniqueUncorrectedErrorCounts_v1_t nvmlEccSramUniqueUncorrectedErrorCounts_t 'nvmlEccSramUniqueUncorrectedErrorCounts_t'
*/
typedef nvmlWorkloadPowerProfileCurrentProfiles_v1_t nvmlWorkloadPowerProfileCurrentProfiles_t;

/* "cy_nvml.pxd":1667
 * ctypedef nvmlWorkloadPowerProfileInfo_v1_t nvmlWorkloadPowerProfileInfo_t 'nvmlWorkloadPowerProfileInfo_t'
 * ctypedef nvmlWorkloadPowerProfileCurrentProfiles_v1_t nvmlWorkloadPowerProfileCurrentProfiles_t 'nvmlWorkloadPowerProfileCurrentProfiles_t'
 * ctypedef nvmlWorkloadPowerProfileRequestedProfiles_v1_t nvmlWorkloadPowerProfileRequestedProfiles_t 'nvmlWorkloadPowerProfileRequestedProfiles_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlEccSramUniqueUncorrectedErrorCounts_v1_t nvmlEccSramUniqueUncorrectedErrorCounts_t 'nvmlEccSramUniqueUncorrectedErrorCounts_t'
 * ctypedef struct nvmlNvLinkInfo_v2_t 'nvmlNvLinkInfo_v2_t':
*/
typedef nvmlWorkloadPowerProfileRequestedProfiles_v1_t nvmlWorkloadPowerProfileRequestedProfiles_t;

/* "cy_nvml.pxd":1668
 * ctypedef nvmlWorkloadPowerProfileCurrentProfiles_v1_t nvmlWorkloadPowerProfileCurrentProfiles_t 'nvmlWorkloadPowerProfileCurrentProfiles_t'
 * ctypedef nvmlWorkloadPowerProfileRequestedProfiles_v1_t nvmlWorkloadPowerProfileRequestedProfiles_t 'nvmlWorkloadPowerProfileRequestedProfiles_t'
 * ctypedef nvmlEccSramUniqueUncorrectedErrorCounts_v1_t nvmlEccSramUniqueUncorrectedErrorCounts_t 'nvmlEccSramUniqueUncorrectedErrorCounts_t'             # <<<<<<<<<<<<<<
 * ctypedef struct nvmlNvLinkInfo_v2_t 'nvmlNvLinkInfo_v2_t':
 *     unsigned int version
*/
typedef nvmlEccSramUniqueUncorrectedErrorCounts_v1_t nvmlEccSramUniqueUncorrectedErrorCounts_t;

/* "cy_nvml.pxd":1669
 * ctypedef nvmlWorkloadPowerProfileRequestedProfiles_v1_t nvmlWorkloadPowerProfileRequestedProfiles_t 'nvmlWorkloadPowerProfileRequestedProfiles_t'
 * ctypedef nvmlEccSramUniqueUncorrectedErrorCounts_v1_t nvmlEccSramUniqueUncorrectedErrorCounts_t 'nvmlEccSramUniqueUncorrectedErrorCounts_t'
 * ctypedef struct nvmlNvLinkInfo_v2_t 'nvmlNvLinkInfo_v2_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     unsigned int isNvleEnabled
*/
struct nvmlNvLinkInfo_v2_t {
  unsigned int version;
  unsigned int isNvleEnabled;
  nvmlNvlinkFirmwareInfo_t firmwareInfo;
};

/* "cy_nvml.pxd":1674
 *     nvmlNvlinkFirmwareInfo_t firmwareInfo
 * 
 * ctypedef nvmlVgpuProcessesUtilizationInfo_v1_t nvmlVgpuProcessesUtilizationInfo_t 'nvmlVgpuProcessesUtilizationInfo_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlVgpuInstancesUtilizationInfo_v1_t nvmlVgpuInstancesUtilizationInfo_t 'nvmlVgpuInstancesUtilizationInfo_t'
 * ctypedef nvmlVgpuSchedulerStateInfo_v1_t nvmlVgpuSchedulerStateInfo_t 'nvmlVgpuSchedulerStateInfo_t'
*/
typedef nvmlVgpuProcessesUtilizationInfo_v1_t nvmlVgpuProcessesUtilizationInfo_t;

/* "cy_nvml.pxd":1675
 * 
 * ctypedef nvmlVgpuProcessesUtilizationInfo_v1_t nvmlVgpuProcessesUtilizationInfo_t 'nvmlVgpuProcessesUtilizationInfo_t'
 * ctypedef nvmlVgpuInstancesUtilizationInfo_v1_t nvmlVgpuInstancesUtilizationInfo_t 'nvmlVgpuInstancesUtilizationInfo_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlVgpuSchedulerStateInfo_v1_t nvmlVgpuSchedulerStateInfo_t 'nvmlVgpuSchedulerStateInfo_t'
 * ctypedef nvmlVgpuSchedulerLogInfo_v1_t nvmlVgpuSchedulerLogInfo_t 'nvmlVgpuSchedulerLogInfo_t'
*/
typedef nvmlVgpuInstancesUtilizationInfo_v1_t nvmlVgpuInstancesUtilizationInfo_t;

/* "cy_nvml.pxd":1676
 * ctypedef nvmlVgpuProcessesUtilizationInfo_v1_t nvmlVgpuProcessesUtilizationInfo_t 'nvmlVgpuProcessesUtilizationInfo_t'
 * ctypedef nvmlVgpuInstancesUtilizationInfo_v1_t nvmlVgpuInstancesUtilizationInfo_t 'nvmlVgpuInstancesUtilizationInfo_t'
 * ctypedef nvmlVgpuSchedulerStateInfo_v1_t nvmlVgpuSchedulerStateInfo_t 'nvmlVgpuSchedulerStateInfo_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlVgpuSchedulerLogInfo_v1_t nvmlVgpuSchedulerLogInfo_t 'nvmlVgpuSchedulerLogInfo_t'
 * ctypedef nvmlVgpuSchedulerState_v1_t nvmlVgpuSchedulerState_t 'nvmlVgpuSchedulerState_t'
*/
typedef nvmlVgpuSchedulerStateInfo_v1_t nvmlVgpuSchedulerStateInfo_t;

/* "cy_nvml.pxd":1677
 * ctypedef nvmlVgpuInstancesUtilizationInfo_v1_t nvmlVgpuInstancesUtilizationInfo_t 'nvmlVgpuInstancesUtilizationInfo_t'
 * ctypedef nvmlVgpuSchedulerStateInfo_v1_t nvmlVgpuSchedulerStateInfo_t 'nvmlVgpuSchedulerStateInfo_t'
 * ctypedef nvmlVgpuSchedulerLogInfo_v1_t nvmlVgpuSchedulerLogInfo_t 'nvmlVgpuSchedulerLogInfo_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlVgpuSchedulerState_v1_t nvmlVgpuSchedulerState_t 'nvmlVgpuSchedulerState_t'
 * ctypedef struct nvmlWorkloadPowerProfileProfilesInfo_v1_t 'nvmlWorkloadPowerProfileProfilesInfo_v1_t':
*/
typedef nvmlVgpuSchedulerLogInfo_v1_t nvmlVgpuSchedulerLogInfo_t;

/* "cy_nvml.pxd":1678
 * ctypedef nvmlVgpuSchedulerStateInfo_v1_t nvmlVgpuSchedulerStateInfo_t 'nvmlVgpuSchedulerStateInfo_t'
 * ctypedef nvmlVgpuSchedulerLogInfo_v1_t nvmlVgpuSchedulerLogInfo_t 'nvmlVgpuSchedulerLogInfo_t'
 * ctypedef nvmlVgpuSchedulerState_v1_t nvmlVgpuSchedulerState_t 'nvmlVgpuSchedulerState_t'             # <<<<<<<<<<<<<<
 * ctypedef struct nvmlWorkloadPowerProfileProfilesInfo_v1_t 'nvmlWorkloadPowerProfileProfilesInfo_v1_t':
 *     unsigned int version
*/
typedef nvmlVgpuSchedulerState_v1_t nvmlVgpuSchedulerState_t;

/* "cy_nvml.pxd":1679
 * ctypedef nvmlVgpuSchedulerLogInfo_v1_t nvmlVgpuSchedulerLogInfo_t 'nvmlVgpuSchedulerLogInfo_t'
 * ctypedef nvmlVgpuSchedulerState_v1_t nvmlVgpuSchedulerState_t 'nvmlVgpuSchedulerState_t'
 * ctypedef struct nvmlWorkloadPowerProfileProfilesInfo_v1_t 'nvmlWorkloadPowerProfileProfilesInfo_v1_t':             # <<<<<<<<<<<<<<
 *     unsigned int version
 *     nvmlMask255_t perfProfilesMask
*/
struct nvmlWorkloadPowerProfileProfilesInfo_v1_t {
  unsigned int version;
  nvmlMask255_t perfProfilesMask;
  nvmlWorkloadPowerProfileInfo_t perfProfile[255];
};

/* "cy_nvml.pxd":1684
 *     nvmlWorkloadPowerProfileInfo_t perfProfile[255]
 * 
 * ctypedef nvmlNvLinkInfo_v2_t nvmlNvLinkInfo_t 'nvmlNvLinkInfo_t'             # <<<<<<<<<<<<<<
 * ctypedef nvmlWorkloadPowerProfileProfilesInfo_v1_t nvmlWorkloadPowerProfileProfilesInfo_t 'nvmlWorkloadPowerProfileProfilesInfo_t'
 * 
*/
typedef nvmlNvLinkInfo_v2_t nvmlNvLinkInfo_t;

/* "cy_nvml.pxd":1685
 * 
 * ctypedef nvmlNvLinkInfo_v2_t nvmlNvLinkInfo_t 'nvmlNvLinkInfo_t'
 * ctypedef nvmlWorkloadPowerProfileProfilesInfo_v1_t nvmlWorkloadPowerProfileProfilesInfo_t 'nvmlWorkloadPowerProfileProfilesInfo_t'             # <<<<<<<<<<<<<<
 * 
 * 
*/
typedef nvmlWorkloadPowerProfileProfilesInfo_v1_t nvmlWorkloadPowerProfileProfilesInfo_t;
/* #### Code section: utility_code_proto ### */

/* --- Runtime support code (head) --- */
/* Refnanny.proto */
#ifndef CYTHON_REFNANNY
  #define CYTHON_REFNANNY 0
#endif
#if CYTHON_REFNANNY
  typedef struct {
    void (*INCREF)(void*, PyObject*, Py_ssize_t);
    void (*DECREF)(void*, PyObject*, Py_ssize_t);
    void (*GOTREF)(void*, PyObject*, Py_ssize_t);
    void (*GIVEREF)(void*, PyObject*, Py_ssize_t);
    void* (*SetupContext)(const char*, Py_ssize_t, const char*);
    void (*FinishContext)(void**);
  } __Pyx_RefNannyAPIStruct;
  static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
  static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);
  #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;
  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
          if (acquire_gil) {\
              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
              PyGILState_Release(__pyx_gilstate_save);\
          } else {\
              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
          }
  #define __Pyx_RefNannyFinishContextNogil() {\
              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
              __Pyx_RefNannyFinishContext();\
              PyGILState_Release(__pyx_gilstate_save);\
          }
  #define __Pyx_RefNannyFinishContextNogil() {\
              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
              __Pyx_RefNannyFinishContext();\
              PyGILState_Release(__pyx_gilstate_save);\
          }
  #define __Pyx_RefNannyFinishContext()\
          __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
  #define __Pyx_XINCREF(r)  do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0)
  #define __Pyx_XDECREF(r)  do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0)
  #define __Pyx_XGOTREF(r)  do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0)
  #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0)
#else
  #define __Pyx_RefNannyDeclarations
  #define __Pyx_RefNannySetupContext(name, acquire_gil)
  #define __Pyx_RefNannyFinishContextNogil()
  #define __Pyx_RefNannyFinishContext()
  #define __Pyx_INCREF(r) Py_INCREF(r)
  #define __Pyx_DECREF(r) Py_DECREF(r)
  #define __Pyx_GOTREF(r)
  #define __Pyx_GIVEREF(r)
  #define __Pyx_XINCREF(r) Py_XINCREF(r)
  #define __Pyx_XDECREF(r) Py_XDECREF(r)
  #define __Pyx_XGOTREF(r)
  #define __Pyx_XGIVEREF(r)
#endif
#define __Pyx_Py_XDECREF_SET(r, v) do {\
        PyObject *tmp = (PyObject *) r;\
        r = v; Py_XDECREF(tmp);\
    } while (0)
#define __Pyx_XDECREF_SET(r, v) do {\
        PyObject *tmp = (PyObject *) r;\
        r = v; __Pyx_XDECREF(tmp);\
    } while (0)
#define __Pyx_DECREF_SET(r, v) do {\
        PyObject *tmp = (PyObject *) r;\
        r = v; __Pyx_DECREF(tmp);\
    } while (0)
#define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
#define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)

/* PyErrExceptionMatches.proto (used by PyObjectGetAttrStrNoError) */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
#else
#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
#endif

/* PyThreadStateGet.proto (used by PyErrFetchRestore) */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
#define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
#if PY_VERSION_HEX >= 0x030C00A6
#define __Pyx_PyErr_Occurred()  (__pyx_tstate->current_exception != NULL)
#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL)
#else
#define __Pyx_PyErr_Occurred()  (__pyx_tstate->curexc_type != NULL)
#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->curexc_type)
#endif
#else
#define __Pyx_PyThreadState_declare
#define __Pyx_PyThreadState_assign
#define __Pyx_PyErr_Occurred()  (PyErr_Occurred() != NULL)
#define __Pyx_PyErr_CurrentExceptionType()  PyErr_Occurred()
#endif

/* PyErrFetchRestore.proto (used by PyObjectGetAttrStrNoError) */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6
#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
#else
#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
#endif
#else
#define __Pyx_PyErr_Clear() PyErr_Clear()
#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
#define __Pyx_ErrRestoreInState(tstate, type, value, tb)  PyErr_Restore(type, value, tb)
#define __Pyx_ErrFetchInState(tstate, type, value, tb)  PyErr_Fetch(type, value, tb)
#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
#endif

/* PyObjectGetAttrStr.proto (used by PyObjectGetAttrStrNoError) */
#if CYTHON_USE_TYPE_SLOTS
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
#else
#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
#endif

/* PyObjectGetAttrStrNoError.proto (used by GetBuiltinName) */
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);

/* GetBuiltinName.proto (used by GetModuleGlobalName) */
static PyObject *__Pyx_GetBuiltinName(PyObject *name);

/* PyDictVersioning.proto (used by GetModuleGlobalName) */
#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
#define __PYX_DICT_VERSION_INIT  ((PY_UINT64_T) -1)
#define __PYX_GET_DICT_VERSION(dict)  (((PyDictObject*)(dict))->ma_version_tag)
#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\
    (version_var) = __PYX_GET_DICT_VERSION(dict);\
    (cache_var) = (value);
#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\
    static PY_UINT64_T __pyx_dict_version = 0;\
    static PyObject *__pyx_dict_cached_value = NULL;\
    if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\
        (VAR) = __Pyx_XNewRef(__pyx_dict_cached_value);\
    } else {\
        (VAR) = __pyx_dict_cached_value = (LOOKUP);\
        __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\
    }\
}
static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj);
static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj);
static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version);
#else
#define __PYX_GET_DICT_VERSION(dict)  (0)
#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)
#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP)  (VAR) = (LOOKUP);
#endif

/* GetModuleGlobalName.proto */
#if CYTHON_USE_DICT_VERSIONS
#define __Pyx_GetModuleGlobalName(var, name)  do {\
    static PY_UINT64_T __pyx_dict_version = 0;\
    static PyObject *__pyx_dict_cached_value = NULL;\
    (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_mstate_global->__pyx_d))) ?\
        (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\
        __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
} while(0)
#define __Pyx_GetModuleGlobalNameUncached(var, name)  do {\
    PY_UINT64_T __pyx_dict_version;\
    PyObject *__pyx_dict_cached_value;\
    (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
} while(0)
static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value);
#else
#define __Pyx_GetModuleGlobalName(var, name)  (var) = __Pyx__GetModuleGlobalName(name)
#define __Pyx_GetModuleGlobalNameUncached(var, name)  (var) = __Pyx__GetModuleGlobalName(name)
static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name);
#endif

/* IncludeStringH.proto (used by decode_c_string) */
#include <string.h>

/* decode_c_string_utf16.proto (used by decode_c_string) */
static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors) {
    int byteorder = 0;
    return PyUnicode_DecodeUTF16(s, size, errors, &byteorder);
}
static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16LE(const char *s, Py_ssize_t size, const char *errors) {
    int byteorder = -1;
    return PyUnicode_DecodeUTF16(s, size, errors, &byteorder);
}
static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16BE(const char *s, Py_ssize_t size, const char *errors) {
    int byteorder = 1;
    return PyUnicode_DecodeUTF16(s, size, errors, &byteorder);
}

/* decode_c_string.proto */
static CYTHON_INLINE PyObject* __Pyx_decode_c_string(
         const char* cstring, Py_ssize_t start, Py_ssize_t stop,
         const char* encoding, const char* errors,
         PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors));

/* JoinPyUnicode.export */
static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength,
                                      Py_UCS4 max_char);

/* PyObjectCall.proto (used by PyObjectFastCall) */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
#else
#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
#endif

/* PyObjectCallMethO.proto (used by PyObjectFastCall) */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
#endif

/* PyObjectFastCall.proto */
#define __Pyx_PyObject_FastCall(func, args, nargs)  __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL)
static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs);

/* RaiseException.export */
static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);

/* PyRuntimeError_Check.proto */
#define __Pyx_PyExc_RuntimeError_Check(obj)  __Pyx_TypeCheck(obj, PyExc_RuntimeError)

/* BuildPyUnicode.proto (used by COrdinalToPyUnicode) */
static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, const char* chars, int clength,
                                                int prepend_sign, char padding_char);

/* COrdinalToPyUnicode.proto (used by CIntToPyUnicode) */
static CYTHON_INLINE int __Pyx_CheckUnicodeValue(int value);
static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromOrdinal_Padded(int value, Py_ssize_t width, char padding_char);

/* GCCDiagnostics.proto (used by CIntToPyUnicode) */
#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
#define __Pyx_HAS_GCC_DIAGNOSTIC
#endif

/* IncludeStdlibH.proto (used by CIntToPyUnicode) */
#include <stdlib.h>

/* CIntToPyUnicode.proto */
#define __Pyx_PyUnicode_From_int(value, width, padding_char, format_char) (\
    ((format_char) == ('c')) ?\
        __Pyx_uchar___Pyx_PyUnicode_From_int(value, width, padding_char) :\
        __Pyx____Pyx_PyUnicode_From_int(value, width, padding_char, format_char)\
    )
static CYTHON_INLINE PyObject* __Pyx_uchar___Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char);
static CYTHON_INLINE PyObject* __Pyx____Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char);

/* PyObjectLookupSpecial.proto */
#if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
#define __Pyx_PyObject_LookupSpecialNoError(obj, attr_name)  __Pyx__PyObject_LookupSpecial(obj, attr_name, 0)
#define __Pyx_PyObject_LookupSpecial(obj, attr_name)  __Pyx__PyObject_LookupSpecial(obj, attr_name, 1)
static CYTHON_INLINE PyObject* __Pyx__PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name, int with_error);
#else
#define __Pyx_PyObject_LookupSpecialNoError(o,n) __Pyx_PyObject_GetAttrStrNoError(o,n)
#define __Pyx_PyObject_LookupSpecial(o,n) __Pyx_PyObject_GetAttrStr(o,n)
#endif

/* GetTopmostException.proto (used by SaveResetException) */
#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE
static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate);
#endif

/* SaveResetException.proto */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_ExceptionSave(type, value, tb)  __Pyx__ExceptionSave(__pyx_tstate, type, value, tb)
static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
#define __Pyx_ExceptionReset(type, value, tb)  __Pyx__ExceptionReset(__pyx_tstate, type, value, tb)
static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
#else
#define __Pyx_ExceptionSave(type, value, tb)   PyErr_GetExcInfo(type, value, tb)
#define __Pyx_ExceptionReset(type, value, tb)  PyErr_SetExcInfo(type, value, tb)
#endif

/* GetException.proto */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_GetException(type, value, tb)  __Pyx__GetException(__pyx_tstate, type, value, tb)
static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
#else
static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb);
#endif

/* TupleAndListFromArray.proto (used by fastcall) */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n);
#endif
#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_METH_FASTCALL
static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n);
#endif

/* BytesEquals.proto (used by UnicodeEquals) */
static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);

/* UnicodeEquals.proto (used by fastcall) */
static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);

/* fastcall.proto */
#if CYTHON_AVOID_BORROWED_REFS
    #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_PySequence_ITEM(args, i)
#elif CYTHON_ASSUME_SAFE_MACROS
    #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_NewRef(__Pyx_PyTuple_GET_ITEM(args, i))
#else
    #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_XNewRef(PyTuple_GetItem(args, i))
#endif
#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds)
#define __Pyx_KwValues_VARARGS(args, nargs) NULL
#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s)
#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw)
#if CYTHON_METH_FASTCALL
    #define __Pyx_ArgRef_FASTCALL(args, i) __Pyx_NewRef(args[i])
    #define __Pyx_NumKwargs_FASTCALL(kwds) __Pyx_PyTuple_GET_SIZE(kwds)
    #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs))
    static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API
    CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues);
  #else
    #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw)
  #endif
#else
    #define __Pyx_ArgRef_FASTCALL __Pyx_ArgRef_VARARGS
    #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS
    #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS
    #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS
    #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS
#endif
#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop)
#if CYTHON_METH_FASTCALL || (CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(args + start, stop - start)
#else
#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop)
#endif

/* DictGetItem.proto */
#if !CYTHON_COMPILING_IN_PYPY
static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key);
#define __Pyx_PyObject_Dict_GetItem(obj, name)\
    (likely(PyDict_CheckExact(obj)) ?\
     __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name))
#else
#define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key)
#define __Pyx_PyObject_Dict_GetItem(obj, name)  PyObject_GetItem(obj, name)
#endif

/* py_dict_items.proto (used by OwnedDictNext) */
static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d);

/* CallCFunction.proto (used by CallUnboundCMethod0) */
#define __Pyx_CallCFunction(cfunc, self, args)\
    ((PyCFunction)(void(*)(void))(cfunc)->func)(self, args)
#define __Pyx_CallCFunctionWithKeywords(cfunc, self, args, kwargs)\
    ((PyCFunctionWithKeywords)(void(*)(void))(cfunc)->func)(self, args, kwargs)
#define __Pyx_CallCFunctionFast(cfunc, self, args, nargs)\
    ((__Pyx_PyCFunctionFast)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs)
#define __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, nargs, kwnames)\
    ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs, kwnames)

/* PyObjectCallOneArg.proto (used by CallUnboundCMethod0) */
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);

/* UnpackUnboundCMethod.proto (used by CallUnboundCMethod0) */
typedef struct {
    PyObject *type;
    PyObject **method_name;
#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && CYTHON_ATOMICS
    __pyx_atomic_int_type initialized;
#endif
    PyCFunction func;
    PyObject *method;
    int flag;
} __Pyx_CachedCFunction;
#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
static CYTHON_INLINE int __Pyx_CachedCFunction_GetAndSetInitializing(__Pyx_CachedCFunction *cfunc) {
#if !CYTHON_ATOMICS
    return 1;
#else
    __pyx_nonatomic_int_type expected = 0;
    if (__pyx_atomic_int_cmp_exchange(&cfunc->initialized, &expected, 1)) {
        return 0;
    }
    return expected;
#endif
}
static CYTHON_INLINE void __Pyx_CachedCFunction_SetFinishedInitializing(__Pyx_CachedCFunction *cfunc) {
#if CYTHON_ATOMICS
    __pyx_atomic_store(&cfunc->initialized, 2);
#endif
}
#else
#define __Pyx_CachedCFunction_GetAndSetInitializing(cfunc) 2
#define __Pyx_CachedCFunction_SetFinishedInitializing(cfunc)
#endif

/* CallUnboundCMethod0.proto */
CYTHON_UNUSED
static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self);
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self);
#else
#define __Pyx_CallUnboundCMethod0(cfunc, self)  __Pyx__CallUnboundCMethod0(cfunc, self)
#endif

/* py_dict_values.proto (used by OwnedDictNext) */
static CYTHON_INLINE PyObject* __Pyx_PyDict_Values(PyObject* d);

/* OwnedDictNext.proto (used by ParseKeywordsImpl) */
#if CYTHON_AVOID_BORROWED_REFS
static int __Pyx_PyDict_NextRef(PyObject *p, PyObject **ppos, PyObject **pkey, PyObject **pvalue);
#else
CYTHON_INLINE
static int __Pyx_PyDict_NextRef(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue);
#endif

/* RaiseDoubleKeywords.proto (used by ParseKeywordsImpl) */
static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);

/* ParseKeywordsImpl.export */
static int __Pyx_ParseKeywordsTuple(
    PyObject *kwds,
    PyObject * const *kwvalues,
    PyObject ** const argnames[],
    PyObject *kwds2,
    PyObject *values[],
    Py_ssize_t num_pos_args,
    Py_ssize_t num_kwargs,
    const char* function_name,
    int ignore_unknown_kwargs
);
static int __Pyx_ParseKeywordDictToDict(
    PyObject *kwds,
    PyObject ** const argnames[],
    PyObject *kwds2,
    PyObject *values[],
    Py_ssize_t num_pos_args,
    const char* function_name
);
static int __Pyx_ParseKeywordDict(
    PyObject *kwds,
    PyObject ** const argnames[],
    PyObject *values[],
    Py_ssize_t num_pos_args,
    Py_ssize_t num_kwargs,
    const char* function_name,
    int ignore_unknown_kwargs
);

/* CallUnboundCMethod2.proto */
CYTHON_UNUSED
static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2);
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2);
#else
#define __Pyx_CallUnboundCMethod2(cfunc, self, arg1, arg2)  __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2)
#endif

/* ParseKeywords.proto */
static CYTHON_INLINE int __Pyx_ParseKeywords(
    PyObject *kwds, PyObject *const *kwvalues, PyObject ** const argnames[],
    PyObject *kwds2, PyObject *values[],
    Py_ssize_t num_pos_args, Py_ssize_t num_kwargs,
    const char* function_name,
    int ignore_unknown_kwargs
);

/* RaiseArgTupleInvalid.proto */
static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);

/* ArgTypeTestFunc.export */
static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact);

/* ArgTypeTest.proto */
#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\
    ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\
        __Pyx__ArgTypeTest(obj, type, name, exact))

/* FunctionExport.proto */
static int __Pyx_ExportFunction(PyObject *api_dict, const char *name, void (*f)(void), const char *sig);

/* GetApiDict.proto */
static PyObject *__Pyx_ApiExport_GetApiDict(void);

/* HasAttr.proto (used by ImportImpl) */
#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
#define __Pyx_HasAttr(o, n)  PyObject_HasAttrWithError(o, n)
#else
static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *);
#endif

/* ImportImpl.export */
static PyObject *__Pyx__Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, PyObject *moddict, int level);

/* Import.proto */
static CYTHON_INLINE PyObject *__Pyx_Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, int level);

/* ImportFrom.proto */
static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name);

/* dict_setdefault.proto (used by FetchCommonType) */
static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value);

/* LimitedApiGetTypeDict.proto (used by SetItemOnTypeDict) */
#if CYTHON_COMPILING_IN_LIMITED_API
static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp);
#endif

/* SetItemOnTypeDict.proto (used by FixUpExtensionType) */
static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v);
#define __Pyx_SetItemOnTypeDict(tp, k, v) __Pyx__SetItemOnTypeDict((PyTypeObject*)tp, k, v)

/* FixUpExtensionType.proto (used by FetchCommonType) */
static CYTHON_INLINE int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type);

/* AddModuleRef.proto (used by FetchSharedCythonModule) */
#if ((CYTHON_COMPILING_IN_CPYTHON_FREETHREADING ) ||\
     __PYX_LIMITED_VERSION_HEX < 0x030d0000)
  static PyObject *__Pyx_PyImport_AddModuleRef(const char *name);
#else
  #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
#endif

/* FetchSharedCythonModule.proto (used by FetchCommonType) */
static PyObject *__Pyx_FetchSharedCythonABIModule(void);

/* FetchCommonType.proto (used by CommonTypesMetaclass) */
static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases);

/* CommonTypesMetaclass.proto (used by CythonFunctionShared) */
static int __pyx_CommonTypesMetaclass_init(PyObject *module);
#define __Pyx_CommonTypesMetaclass_USED

/* CallTypeTraverse.proto (used by CythonFunctionShared) */
#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000)
#define __Pyx_call_type_traverse(o, always_call, visit, arg) 0
#else
static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg);
#endif

/* PyMethodNew.proto (used by CythonFunctionShared) */
static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ);

/* PyVectorcallFastCallDict.proto (used by CythonFunctionShared) */
#if CYTHON_METH_FASTCALL && CYTHON_VECTORCALL
static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw);
#endif

/* CythonFunctionShared.proto (used by CythonFunction) */
#define __Pyx_CyFunction_USED
#define __Pyx_CYFUNCTION_STATICMETHOD  0x01
#define __Pyx_CYFUNCTION_CLASSMETHOD   0x02
#define __Pyx_CYFUNCTION_CCLASS        0x04
#define __Pyx_CYFUNCTION_COROUTINE     0x08
#define __Pyx_CyFunction_GetClosure(f)\
    (((__pyx_CyFunctionObject *) (f))->func_closure)
#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
  #define __Pyx_CyFunction_GetClassObj(f)\
      (((__pyx_CyFunctionObject *) (f))->func_classobj)
#else
  #define __Pyx_CyFunction_GetClassObj(f)\
      ((PyObject*) ((PyCMethodObject *) (f))->mm_class)
#endif
#define __Pyx_CyFunction_SetClassObj(f, classobj)\
    __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj))
#define __Pyx_CyFunction_Defaults(type, f)\
    ((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\
    ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
typedef struct {
#if CYTHON_COMPILING_IN_LIMITED_API
    PyObject_HEAD
    PyObject *func;
#elif PY_VERSION_HEX < 0x030900B1
    PyCFunctionObject func;
#else
    PyCMethodObject func;
#endif
#if CYTHON_COMPILING_IN_LIMITED_API && CYTHON_METH_FASTCALL
    __pyx_vectorcallfunc func_vectorcall;
#endif
#if CYTHON_COMPILING_IN_LIMITED_API
    PyObject *func_weakreflist;
#endif
#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API
    PyObject *func_dict;
#endif
    PyObject *func_name;
    PyObject *func_qualname;
    PyObject *func_doc;
    PyObject *func_globals;
    PyObject *func_code;
    PyObject *func_closure;
#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
    PyObject *func_classobj;
#endif
    PyObject *defaults;
    int flags;
    PyObject *defaults_tuple;
    PyObject *defaults_kwdict;
    PyObject *(*defaults_getter)(PyObject *);
    PyObject *func_annotations;
    PyObject *func_is_coroutine;
} __pyx_CyFunctionObject;
#undef __Pyx_CyOrPyCFunction_Check
#define __Pyx_CyFunction_Check(obj)  __Pyx_TypeCheck(obj, __pyx_mstate_global->__pyx_CyFunctionType)
#define __Pyx_CyOrPyCFunction_Check(obj)  __Pyx_TypeCheck2(obj, __pyx_mstate_global->__pyx_CyFunctionType, &PyCFunction_Type)
#define __Pyx_CyFunction_CheckExact(obj)  __Pyx_IS_TYPE(obj, __pyx_mstate_global->__pyx_CyFunctionType)
static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void));
#undef __Pyx_IsSameCFunction
#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCyOrCFunction(func, cfunc)
static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml,
                                      int flags, PyObject* qualname,
                                      PyObject *closure,
                                      PyObject *module, PyObject *globals,
                                      PyObject* code);
static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj);
static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func,
                                                         PyTypeObject *defaults_type);
static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m,
                                                            PyObject *tuple);
static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m,
                                                             PyObject *dict);
static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
                                                              PyObject *dict);
static int __pyx_CyFunction_init(PyObject *module);
#if CYTHON_METH_FASTCALL
static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
#if CYTHON_COMPILING_IN_LIMITED_API
#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall)
#else
#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall)
#endif
#endif

/* CythonFunction.proto */
static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml,
                                      int flags, PyObject* qualname,
                                      PyObject *closure,
                                      PyObject *module, PyObject *globals,
                                      PyObject* code);

/* CLineInTraceback.proto (used by AddTraceback) */
#if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME
static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
#else
#define __Pyx_CLineForTraceback(tstate, c_line)  (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0)
#endif

/* CodeObjectCache.proto (used by AddTraceback) */
#if CYTHON_COMPILING_IN_LIMITED_API
typedef PyObject __Pyx_CachedCodeObjectType;
#else
typedef PyCodeObject __Pyx_CachedCodeObjectType;
#endif
typedef struct {
    __Pyx_CachedCodeObjectType* code_object;
    int code_line;
} __Pyx_CodeObjectCacheEntry;
struct __Pyx_CodeObjectCache {
    int count;
    int max_count;
    __Pyx_CodeObjectCacheEntry* entries;
  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
    __pyx_atomic_int_type accessor_count;
  #endif
};
static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line);
static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object);

/* AddTraceback.proto */
static void __Pyx_AddTraceback(const char *funcname, int c_line,
                               int py_line, const char *filename);

/* FormatTypeName.proto */
#if CYTHON_COMPILING_IN_LIMITED_API
typedef PyObject *__Pyx_TypeName;
#define __Pyx_FMT_TYPENAME "%U"
#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj)
#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
#define __Pyx_PyType_GetFullyQualifiedName PyType_GetFullyQualifiedName
#else
static __Pyx_TypeName __Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp);
#endif
#else  // !LIMITED_API
typedef const char *__Pyx_TypeName;
#define __Pyx_FMT_TYPENAME "%.200s"
#define __Pyx_PyType_GetFullyQualifiedName(tp) ((tp)->tp_name)
#define __Pyx_DECREF_TypeName(obj)
#endif

/* PyObjectVectorCallKwBuilder.proto (used by CIntToPy) */
CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n);
#if CYTHON_VECTORCALL
#if PY_VERSION_HEX >= 0x03090000
#define __Pyx_Object_Vectorcall_CallFromBuilder PyObject_Vectorcall
#else
#define __Pyx_Object_Vectorcall_CallFromBuilder _PyObject_Vectorcall
#endif
#define __Pyx_MakeVectorcallBuilderKwds(n) PyTuple_New(n)
static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n);
static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n);
#else
#define __Pyx_Object_Vectorcall_CallFromBuilder __Pyx_PyObject_FastCallDict
#define __Pyx_MakeVectorcallBuilderKwds(n) __Pyx_PyDict_NewPresized(n)
#define __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n) PyDict_SetItem(builder, key, value)
#define __Pyx_VectorcallBuilder_AddArgStr(key, value, builder, args, n) PyDict_SetItemString(builder, key, value)
#endif

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value);

/* CIntFromPy.proto */
static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *);

/* FastTypeChecks.proto */
#if CYTHON_COMPILING_IN_CPYTHON
#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2)
static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b);
static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
#else
#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2))
#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2) {
    return PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2);
}
#endif
#define __Pyx_PyErr_ExceptionMatches2(err1, err2)  __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2)
#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
#ifdef PyExceptionInstance_Check
  #define __Pyx_PyBaseException_Check(obj) PyExceptionInstance_Check(obj)
#else
  #define __Pyx_PyBaseException_Check(obj) __Pyx_TypeCheck(obj, PyExc_BaseException)
#endif

/* GetRuntimeVersion.proto */
#if __PYX_LIMITED_VERSION_HEX < 0x030b0000
static unsigned long __Pyx_cached_runtime_version = 0;
static void __Pyx_init_runtime_version(void);
#else
#define __Pyx_init_runtime_version()
#endif
static unsigned long __Pyx_get_runtime_version(void);

/* CheckBinaryVersion.proto */
static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer);

/* DecompressString.proto */
static PyObject *__Pyx_DecompressString(const char *s, Py_ssize_t length, int algo);

/* MultiPhaseInitModuleState.proto */
#if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE
static PyObject *__Pyx_State_FindModule(void*);
static int __Pyx_State_AddModule(PyObject* module, void*);
static int __Pyx_State_RemoveModule(void*);
#elif CYTHON_USE_MODULE_STATE
#define __Pyx_State_FindModule PyState_FindModule
#define __Pyx_State_AddModule PyState_AddModule
#define __Pyx_State_RemoveModule PyState_RemoveModule
#endif

/* #### Code section: module_declarations ### */
/* CythonABIVersion.proto */
#if CYTHON_COMPILING_IN_LIMITED_API
    #if CYTHON_METH_FASTCALL
        #define __PYX_FASTCALL_ABI_SUFFIX  "_fastcall"
    #else
        #define __PYX_FASTCALL_ABI_SUFFIX
    #endif
    #define __PYX_LIMITED_ABI_SUFFIX "limited" __PYX_FASTCALL_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX
#else
    #define __PYX_LIMITED_ABI_SUFFIX
#endif
#if __PYX_HAS_PY_AM_SEND == 1
    #define __PYX_AM_SEND_ABI_SUFFIX
#elif __PYX_HAS_PY_AM_SEND == 2
    #define __PYX_AM_SEND_ABI_SUFFIX "amsendbackport"
#else
    #define __PYX_AM_SEND_ABI_SUFFIX "noamsend"
#endif
#ifndef __PYX_MONITORING_ABI_SUFFIX
    #define __PYX_MONITORING_ABI_SUFFIX
#endif
#if CYTHON_USE_TP_FINALIZE
    #define __PYX_TP_FINALIZE_ABI_SUFFIX
#else
    #define __PYX_TP_FINALIZE_ABI_SUFFIX "nofinalize"
#endif
#if CYTHON_USE_FREELISTS || !defined(__Pyx_AsyncGen_USED)
    #define __PYX_FREELISTS_ABI_SUFFIX
#else
    #define __PYX_FREELISTS_ABI_SUFFIX "nofreelists"
#endif
#define CYTHON_ABI  __PYX_ABI_VERSION __PYX_LIMITED_ABI_SUFFIX __PYX_MONITORING_ABI_SUFFIX __PYX_TP_FINALIZE_ABI_SUFFIX __PYX_FREELISTS_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX
#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI
#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "."


/* Module declarations from "libc.stdint" */

/* Module declarations from "cuda.bindings.cy_nvml" */

/* Module declarations from "cuda.bindings._internal._nvml" */
static PyObject *__pyx_v_4cuda_8bindings_9_internal_5_nvml___symbol_lock = 0;
static int __pyx_v_4cuda_8bindings_9_internal_5_nvml___py_nvml_init;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlInit_v2;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlInitWithFlags;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlShutdown;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlErrorString;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetDriverVersion;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetNVMLVersion;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetCudaDriverVersion;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetCudaDriverVersion_v2;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetProcessName;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetHicVersion;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetTopologyGpuSet;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetDriverBranch;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetCount;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetHandleByIndex;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetUnitInfo;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetLedState;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetPsuInfo;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetTemperature;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetFanSpeedInfo;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetDevices;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCount_v2;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAttributes_v2;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByIndex_v2;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleBySerial;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByUUID;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByUUIDV;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByPciBusId_v2;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetName;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBrand;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetIndex;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSerial;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetModuleId;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetC2cModeInfoV;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryAffinity;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCpuAffinityWithinScope;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCpuAffinity;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetCpuAffinity;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearCpuAffinity;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNumaNodeId;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTopologyCommonAncestor;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTopologyNearestGpus;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetP2PStatus;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetUUID;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMinorNumber;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBoardPartNumber;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetInforomVersion;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetInforomImageVersion;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetInforomConfigurationChecksum;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceValidateInforom;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetLastBBXFlushTime;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDisplayMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDisplayActive;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPersistenceMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPciInfoExt;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPciInfo_v3;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxPcieLinkGeneration;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuMaxPcieLinkGeneration;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxPcieLinkWidth;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrPcieLinkGeneration;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrPcieLinkWidth;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieThroughput;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieReplayCounter;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClockInfo;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxClockInfo;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpcClkVfOffset;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClock;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxCustomerBoostClock;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedMemoryClocks;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedGraphicsClocks;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAutoBoostedClocksEnabled;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanSpeed;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanSpeed_v2;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanSpeedRPM;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTargetFanSpeed;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMinMaxFanSpeed;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanControlPolicy_v2;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNumFans;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCoolerInfo;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTemperatureV;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTemperatureThreshold;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMarginTemperature;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetThermalSettings;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPerformanceState;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrentClocksEventReasons;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedClocksEventReasons;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerState;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDynamicPstatesInfo;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemClkVfOffset;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMinMaxClockOfPState;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedPerformanceStates;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpcClkMinMaxVfOffset;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemClkMinMaxVfOffset;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClockOffsets;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetClockOffsets;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPerformanceModes;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrentClockFreqs;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerManagementLimit;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerManagementLimitConstraints;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerManagementDefaultLimit;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerUsage;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTotalEnergyConsumption;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEnforcedPowerLimit;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuOperationMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryInfo_v2;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetComputeMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCudaComputeCapability;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDramEncryptionMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDramEncryptionMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEccMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDefaultEccMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBoardId;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMultiGpuBoard;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTotalEccErrors;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryErrorCounter;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetUtilizationRates;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderUtilization;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderCapacity;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderStats;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderSessions;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDecoderUtilization;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetJpgUtilization;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetOfaUtilization;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFBCStats;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFBCSessions;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDriverModel_v2;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVbiosVersion;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBridgeChipInfo;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetComputeRunningProcesses_v3;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMPSComputeRunningProcesses_v3;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRunningProcessDetailList;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceOnSameBoard;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAPIRestriction;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSamples;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBAR1MemoryInfo;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetIrqNum;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNumGpuCores;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerSource;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryBusWidth;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieLinkMaxSpeed;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieSpeed;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAdaptiveClockInfoStatus;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBusType;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuFabricInfoV;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeCapabilities;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeState;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeMemSizeInfo;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeGpusReadyState;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeProtectedMemoryUsage;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeGpuCertificate;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeGpuAttestationReport;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeKeyRotationThresholdInfo;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetConfComputeUnprotectedMemSize;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemSetConfComputeGpusReadyState;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemSetConfComputeKeyRotationThresholdInfo;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeSettings;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGspFirmwareVersion;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGspFirmwareMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSramEccErrorStatus;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingStats;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingPids;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingBufferSize;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRetiredPages;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRetiredPages_v2;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRetiredPagesPendingStatus;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRemappedRows;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRowRemapperHistogram;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetArchitecture;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClkMonStatus;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetProcessUtilization;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetProcessesUtilizationInfo;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPlatformInfo;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitSetLedState;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPersistenceMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetComputeMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetEccMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearEccErrorCounts;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDriverModel;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetGpuLockedClocks;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceResetGpuLockedClocks;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetMemoryLockedClocks;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceResetMemoryLockedClocks;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetAutoBoostedClocksEnabled;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDefaultAutoBoostedClocksEnabled;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDefaultFanSpeed_v2;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetFanControlPolicy;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetTemperatureThreshold;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPowerManagementLimit;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetGpuOperationMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetAPIRestriction;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetFanSpeed_v2;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetAccountingMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearAccountingPids;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPowerManagementLimit_v2;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkState;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkVersion;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkCapability;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkRemotePciInfo_v2;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkErrorCounter;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceResetNvLinkErrorCounters;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkRemoteDeviceType;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetNvLinkDeviceLowPowerThreshold;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemSetNvlinkBwMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetNvlinkBwMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvlinkSupportedBwModes;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvlinkBwMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetNvlinkBwMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlEventSetCreate;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceRegisterEvents;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedEventTypes;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlEventSetWait_v2;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlEventSetFree;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemEventSetCreate;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemEventSetFree;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemRegisterEvents;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemEventSetWait;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceModifyDrainState;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceQueryDrainState;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceRemoveGpu_v2;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceDiscoverGpus;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFieldValues;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearFieldValues;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVirtualizationMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHostVgpuMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVirtualizationMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuHeterogeneousMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVgpuHeterogeneousMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetPlacementId;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuTypeSupportedPlacements;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuTypeCreatablePlacements;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetGspHeapSize;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetFbReservation;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetRuntimeStateSize;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVgpuCapabilities;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGridLicensableFeatures_v4;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetVgpuDriverCapabilities;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuCapabilities;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedVgpus;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCreatableVgpus;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetClass;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetName;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetGpuInstanceProfileId;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetDeviceID;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetFramebufferSize;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetNumDisplayHeads;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetResolution;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetLicense;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetFrameRateLimit;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetMaxInstances;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetMaxInstancesPerVm;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetBAR1Info;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetActiveVgpus;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetVmID;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetUUID;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetVmDriverVersion;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFbUsage;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetLicenseStatus;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetType;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFrameRateLimit;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEccMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEncoderCapacity;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceSetEncoderCapacity;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEncoderStats;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEncoderSessions;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFBCStats;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFBCSessions;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetGpuInstanceId;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetGpuPciId;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetCapabilities;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetMdevUUID;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetCreatableVgpus;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetMaxInstancesPerGpuInstance;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetActiveVgpus;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceSetVgpuSchedulerState;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuSchedulerState;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuSchedulerLog;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuTypeCreatablePlacements;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuHeterogeneousMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceSetVgpuHeterogeneousMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetMetadata;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuMetadata;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetVgpuCompatibility;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPgpuMetadataString;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuSchedulerLog;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuSchedulerState;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuSchedulerCapabilities;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVgpuSchedulerState;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetVgpuVersion;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSetVgpuVersion;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuUtilization;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuInstancesUtilizationInfo;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuProcessUtilization;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuProcessesUtilizationInfo;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetAccountingMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetAccountingPids;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetAccountingStats;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceClearAccountingPids;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetLicenseInfo_v2;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetExcludedDeviceCount;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetExcludedDeviceInfoByIndex;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetMigMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMigMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceProfileInfoV;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstancePossiblePlacements_v2;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceRemainingCapacity;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceCreateGpuInstance;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceCreateGpuInstanceWithPlacement;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceDestroy;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstances;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceById;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetInfo;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstanceProfileInfoV;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstanceRemainingCapacity;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstancePossiblePlacements;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceCreateComputeInstance;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceCreateComputeInstanceWithPlacement;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlComputeInstanceDestroy;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstances;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstanceById;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlComputeInstanceGetInfo_v2;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceIsMigDeviceHandle;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceId;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetComputeInstanceId;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxMigDeviceCount;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMigDeviceHandleByIndex;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDeviceHandleFromMigDeviceHandle;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmSampleGet;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmMigSampleGet;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmQueryDeviceSupport;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmQueryIfStreamingEnabled;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmSetStreamingEnabled;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCapabilities;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceWorkloadPowerProfileClearRequestedProfiles;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDevicePowerSmoothingActivatePresetProfile;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDevicePowerSmoothingUpdatePresetProfileParam;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDevicePowerSmoothingSetState;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAddressingMode;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRepairStatus;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerMizerMode_v1;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPowerMizerMode_v1;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPdi;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetHostname_v1;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHostname_v1;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkInfo;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceReadWritePRM_v1;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceProfileInfoByIdV;
static void *__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts;
static PyObject *__pyx_v_4cuda_8bindings_9_internal_5_nvml_func_ptrs = 0;
static void *__pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(void); /*proto*/
static int __pyx_f_4cuda_8bindings_9_internal_5_nvml__init_nvml(void); /*proto*/
static CYTHON_INLINE int __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(void); /*proto*/
static PyObject *__pyx_f_4cuda_8bindings_9_internal_5_nvml__inspect_function_pointers(int __pyx_skip_dispatch); /*proto*/
static PyObject *__pyx_f_4cuda_8bindings_9_internal_5_nvml__inspect_function_pointer(PyObject *, int __pyx_skip_dispatch); /*proto*/
/* #### Code section: typeinfo ### */
/* #### Code section: before_global_var ### */
#define __Pyx_MODULE_NAME "cuda.bindings._internal._nvml"
extern int __pyx_module_is_main_cuda__bindings___internal___nvml;
int __pyx_module_is_main_cuda__bindings___internal___nvml = 0;

/* Implementation of "cuda.bindings._internal._nvml" */
/* #### Code section: global_var ### */
/* #### Code section: string_decls ### */
static const char __pyx_k_nvmlInit_v2[] = "nvmlInit_v2";
static const char __pyx_k_libcuda_so_1[] = "libcuda.so.1";
static const char __pyx_k_nvmlShutdown[] = "nvmlShutdown";
static const char __pyx_k_nvmlErrorString[] = "nvmlErrorString";
static const char __pyx_k_nvmlDeviceGetPdi[] = "nvmlDeviceGetPdi";
static const char __pyx_k_nvmlEventSetFree[] = "nvmlEventSetFree";
static const char __pyx_k_nvmlGpmSampleGet[] = "nvmlGpmSampleGet";
static const char __pyx_k_nvmlUnitGetCount[] = "nvmlUnitGetCount";
static const char __pyx_k_libnvidia_ml_so_1[] = "libnvidia-ml.so.1";
static const char __pyx_k_nvmlDeviceGetName[] = "nvmlDeviceGetName";
static const char __pyx_k_nvmlDeviceGetUUID[] = "nvmlDeviceGetUUID";
static const char __pyx_k_nvmlInitWithFlags[] = "nvmlInitWithFlags";
static const char __pyx_k_cuDriverGetVersion[] = "cuDriverGetVersion";
static const char __pyx_k_nvmlDeviceGetBrand[] = "nvmlDeviceGetBrand";
static const char __pyx_k_nvmlDeviceGetClock[] = "nvmlDeviceGetClock";
static const char __pyx_k_nvmlDeviceGetIndex[] = "nvmlDeviceGetIndex";
static const char __pyx_k_nvmlEventSetCreate[] = "nvmlEventSetCreate";
static const char __pyx_k_nvmlGetVgpuVersion[] = "nvmlGetVgpuVersion";
static const char __pyx_k_nvmlSetVgpuVersion[] = "nvmlSetVgpuVersion";
static const char __pyx_k_nvmlUnitGetDevices[] = "nvmlUnitGetDevices";
static const char __pyx_k_nvmlUnitGetPsuInfo[] = "nvmlUnitGetPsuInfo";
static const char __pyx_k_nvmlDeviceGetIrqNum[] = "nvmlDeviceGetIrqNum";
static const char __pyx_k_nvmlDeviceGetSerial[] = "nvmlDeviceGetSerial";
static const char __pyx_k_nvmlEventSetWait_v2[] = "nvmlEventSetWait_v2";
static const char __pyx_k_nvmlGpmMigSampleGet[] = "nvmlGpmMigSampleGet";
static const char __pyx_k_nvmlUnitGetLedState[] = "nvmlUnitGetLedState";
static const char __pyx_k_nvmlUnitGetUnitInfo[] = "nvmlUnitGetUnitInfo";
static const char __pyx_k_nvmlUnitSetLedState[] = "nvmlUnitSetLedState";
static const char __pyx_k_nvmlVgpuTypeGetName[] = "nvmlVgpuTypeGetName";
static const char __pyx_k_nvmlDeviceGetBoardId[] = "nvmlDeviceGetBoardId";
static const char __pyx_k_nvmlDeviceGetBusType[] = "nvmlDeviceGetBusType";
static const char __pyx_k_nvmlDeviceGetEccMode[] = "nvmlDeviceGetEccMode";
static const char __pyx_k_nvmlDeviceGetMigMode[] = "nvmlDeviceGetMigMode";
static const char __pyx_k_nvmlDeviceGetNumFans[] = "nvmlDeviceGetNumFans";
static const char __pyx_k_nvmlDeviceGetSamples[] = "nvmlDeviceGetSamples";
static const char __pyx_k_nvmlDeviceSetEccMode[] = "nvmlDeviceSetEccMode";
static const char __pyx_k_nvmlDeviceSetMigMode[] = "nvmlDeviceSetMigMode";
static const char __pyx_k_nvmlVgpuTypeGetClass[] = "nvmlVgpuTypeGetClass";
static const char __pyx_k_nvmlDeviceGetCount_v2[] = "nvmlDeviceGetCount_v2";
static const char __pyx_k_nvmlDeviceGetFBCStats[] = "nvmlDeviceGetFBCStats";
static const char __pyx_k_nvmlDeviceGetFanSpeed[] = "nvmlDeviceGetFanSpeed";
static const char __pyx_k_nvmlDeviceGetModuleId[] = "nvmlDeviceGetModuleId";
static const char __pyx_k_nvmlDeviceOnSameBoard[] = "nvmlDeviceOnSameBoard";
static const char __pyx_k_nvmlDeviceDiscoverGpus[] = "nvmlDeviceDiscoverGpus";
static const char __pyx_k_nvmlDeviceGetClockInfo[] = "nvmlDeviceGetClockInfo";
static const char __pyx_k_nvmlDeviceGetP2PStatus[] = "nvmlDeviceGetP2PStatus";
static const char __pyx_k_nvmlDeviceGetPcieSpeed[] = "nvmlDeviceGetPcieSpeed";
static const char __pyx_k_nvmlDeviceRemoveGpu_v2[] = "nvmlDeviceRemoveGpu_v2";
static const char __pyx_k_nvmlGpuInstanceDestroy[] = "nvmlGpuInstanceDestroy";
static const char __pyx_k_nvmlGpuInstanceGetInfo[] = "nvmlGpuInstanceGetInfo";
static const char __pyx_k_nvmlSystemEventSetFree[] = "nvmlSystemEventSetFree";
static const char __pyx_k_nvmlSystemEventSetWait[] = "nvmlSystemEventSetWait";
static const char __pyx_k_nvmlUnitGetTemperature[] = "nvmlUnitGetTemperature";
static const char __pyx_k_nvmlVgpuTypeGetLicense[] = "nvmlVgpuTypeGetLicense";
static const char __pyx_k_nvmlDeviceGetCoolerInfo[] = "nvmlDeviceGetCoolerInfo";
static const char __pyx_k_nvmlDeviceGetNumaNodeId[] = "nvmlDeviceGetNumaNodeId";
static const char __pyx_k_nvmlDeviceGetNvLinkInfo[] = "nvmlDeviceGetNvLinkInfo";
static const char __pyx_k_nvmlDeviceGetPciInfoExt[] = "nvmlDeviceGetPciInfoExt";
static const char __pyx_k_nvmlDeviceGetPciInfo_v3[] = "nvmlDeviceGetPciInfo_v3";
static const char __pyx_k_nvmlDeviceGetPowerState[] = "nvmlDeviceGetPowerState";
static const char __pyx_k_nvmlDeviceGetPowerUsage[] = "nvmlDeviceGetPowerUsage";
static const char __pyx_k_nvmlSystemGetHicVersion[] = "nvmlSystemGetHicVersion";
static const char __pyx_k_nvmlUnitGetFanSpeedInfo[] = "nvmlUnitGetFanSpeedInfo";
static const char __pyx_k_nvmlVgpuInstanceGetType[] = "nvmlVgpuInstanceGetType";
static const char __pyx_k_nvmlVgpuInstanceGetUUID[] = "nvmlVgpuInstanceGetUUID";
static const char __pyx_k_nvmlVgpuInstanceGetVmID[] = "nvmlVgpuInstanceGetVmID";
static const char __pyx_k_nvmlVgpuTypeGetBAR1Info[] = "nvmlVgpuTypeGetBAR1Info";
static const char __pyx_k_nvmlVgpuTypeGetDeviceID[] = "nvmlVgpuTypeGetDeviceID";
static const char __pyx_k_nvmlDeviceGetActiveVgpus[] = "nvmlDeviceGetActiveVgpus";
static const char __pyx_k_nvmlDeviceGetComputeMode[] = "nvmlDeviceGetComputeMode";
static const char __pyx_k_nvmlDeviceGetCpuAffinity[] = "nvmlDeviceGetCpuAffinity";
static const char __pyx_k_nvmlDeviceGetDisplayMode[] = "nvmlDeviceGetDisplayMode";
static const char __pyx_k_nvmlDeviceGetFBCSessions[] = "nvmlDeviceGetFBCSessions";
static const char __pyx_k_nvmlDeviceGetFanSpeedRPM[] = "nvmlDeviceGetFanSpeedRPM";
static const char __pyx_k_nvmlDeviceGetFanSpeed_v2[] = "nvmlDeviceGetFanSpeed_v2";
static const char __pyx_k_nvmlDeviceGetFieldValues[] = "nvmlDeviceGetFieldValues";
static const char __pyx_k_nvmlDeviceGetHostname_v1[] = "nvmlDeviceGetHostname_v1";
static const char __pyx_k_nvmlDeviceGetMinorNumber[] = "nvmlDeviceGetMinorNumber";
static const char __pyx_k_nvmlDeviceGetNumGpuCores[] = "nvmlDeviceGetNumGpuCores";
static const char __pyx_k_nvmlDeviceGetNvLinkState[] = "nvmlDeviceGetNvLinkState";
static const char __pyx_k_nvmlDeviceGetPowerSource[] = "nvmlDeviceGetPowerSource";
static const char __pyx_k_nvmlDeviceRegisterEvents[] = "nvmlDeviceRegisterEvents";
static const char __pyx_k_nvmlDeviceSetComputeMode[] = "nvmlDeviceSetComputeMode";
static const char __pyx_k_nvmlDeviceSetCpuAffinity[] = "nvmlDeviceSetCpuAffinity";
static const char __pyx_k_nvmlDeviceSetDriverModel[] = "nvmlDeviceSetDriverModel";
static const char __pyx_k_nvmlDeviceSetFanSpeed_v2[] = "nvmlDeviceSetFanSpeed_v2";
static const char __pyx_k_nvmlDeviceSetHostname_v1[] = "nvmlDeviceSetHostname_v1";
static const char __pyx_k_nvmlGetVgpuCompatibility[] = "nvmlGetVgpuCompatibility";
static const char __pyx_k_nvmlSystemEventSetCreate[] = "nvmlSystemEventSetCreate";
static const char __pyx_k_nvmlSystemGetNVMLVersion[] = "nvmlSystemGetNVMLVersion";
static const char __pyx_k_nvmlSystemGetProcessName[] = "nvmlSystemGetProcessName";
static const char __pyx_k_nvmlSystemRegisterEvents[] = "nvmlSystemRegisterEvents";
static const char __pyx_k_nvmlUnitGetHandleByIndex[] = "nvmlUnitGetHandleByIndex";
static const char __pyx_k_nvmlDeviceGetArchitecture[] = "nvmlDeviceGetArchitecture";
static const char __pyx_k_nvmlDeviceGetC2cModeInfoV[] = "nvmlDeviceGetC2cModeInfoV";
static const char __pyx_k_nvmlDeviceGetCapabilities[] = "nvmlDeviceGetCapabilities";
static const char __pyx_k_nvmlDeviceGetClkMonStatus[] = "nvmlDeviceGetClkMonStatus";
static const char __pyx_k_nvmlDeviceGetClockOffsets[] = "nvmlDeviceGetClockOffsets";
static const char __pyx_k_nvmlDeviceGetEncoderStats[] = "nvmlDeviceGetEncoderStats";
static const char __pyx_k_nvmlDeviceGetGpuInstances[] = "nvmlDeviceGetGpuInstances";
static const char __pyx_k_nvmlDeviceGetHandleByUUID[] = "nvmlDeviceGetHandleByUUID";
static const char __pyx_k_nvmlDeviceGetHostVgpuMode[] = "nvmlDeviceGetHostVgpuMode";
static const char __pyx_k_nvmlDeviceGetMaxClockInfo[] = "nvmlDeviceGetMaxClockInfo";
static const char __pyx_k_nvmlDeviceGetNvlinkBwMode[] = "nvmlDeviceGetNvlinkBwMode";
static const char __pyx_k_nvmlDeviceGetPlatformInfo[] = "nvmlDeviceGetPlatformInfo";
static const char __pyx_k_nvmlDeviceGetRemappedRows[] = "nvmlDeviceGetRemappedRows";
static const char __pyx_k_nvmlDeviceGetRepairStatus[] = "nvmlDeviceGetRepairStatus";
static const char __pyx_k_nvmlDeviceGetRetiredPages[] = "nvmlDeviceGetRetiredPages";
static const char __pyx_k_nvmlDeviceGetTemperatureV[] = "nvmlDeviceGetTemperatureV";
static const char __pyx_k_nvmlDeviceGetVbiosVersion[] = "nvmlDeviceGetVbiosVersion";
static const char __pyx_k_nvmlDeviceGetVgpuMetadata[] = "nvmlDeviceGetVgpuMetadata";
static const char __pyx_k_nvmlDeviceQueryDrainState[] = "nvmlDeviceQueryDrainState";
static const char __pyx_k_nvmlDeviceReadWritePRM_v1[] = "nvmlDeviceReadWritePRM_v1";
static const char __pyx_k_nvmlDeviceSetClockOffsets[] = "nvmlDeviceSetClockOffsets";
static const char __pyx_k_nvmlDeviceSetNvlinkBwMode[] = "nvmlDeviceSetNvlinkBwMode";
static const char __pyx_k_nvmlDeviceValidateInforom[] = "nvmlDeviceValidateInforom";
static const char __pyx_k_nvmlGpmQueryDeviceSupport[] = "nvmlGpmQueryDeviceSupport";
static const char __pyx_k_nvmlSystemGetDriverBranch[] = "nvmlSystemGetDriverBranch";
static const char __pyx_k_nvmlSystemGetNvlinkBwMode[] = "nvmlSystemGetNvlinkBwMode";
static const char __pyx_k_nvmlSystemSetNvlinkBwMode[] = "nvmlSystemSetNvlinkBwMode";
static const char __pyx_k_nvmlVgpuTypeGetResolution[] = "nvmlVgpuTypeGetResolution";
static const char __pyx_k_nvmlComputeInstanceDestroy[] = "nvmlComputeInstanceDestroy";
static const char __pyx_k_nvmlDeviceClearCpuAffinity[] = "nvmlDeviceClearCpuAffinity";
static const char __pyx_k_nvmlDeviceClearFieldValues[] = "nvmlDeviceClearFieldValues";
static const char __pyx_k_nvmlDeviceGetAttributes_v2[] = "nvmlDeviceGetAttributes_v2";
static const char __pyx_k_nvmlDeviceGetDisplayActive[] = "nvmlDeviceGetDisplayActive";
static const char __pyx_k_nvmlDeviceGetGpuInstanceId[] = "nvmlDeviceGetGpuInstanceId";
static const char __pyx_k_nvmlDeviceGetHandleByUUIDV[] = "nvmlDeviceGetHandleByUUIDV";
static const char __pyx_k_nvmlDeviceGetMemoryInfo_v2[] = "nvmlDeviceGetMemoryInfo_v2";
static const char __pyx_k_nvmlDeviceGetMultiGpuBoard[] = "nvmlDeviceGetMultiGpuBoard";
static const char __pyx_k_nvmlDeviceGetNvLinkVersion[] = "nvmlDeviceGetNvLinkVersion";
static const char __pyx_k_nvmlDeviceModifyDrainState[] = "nvmlDeviceModifyDrainState";
static const char __pyx_k_nvmlGetExcludedDeviceCount[] = "nvmlGetExcludedDeviceCount";
static const char __pyx_k_nvmlGpmSetStreamingEnabled[] = "nvmlGpmSetStreamingEnabled";
static const char __pyx_k_nvmlSystemGetDriverVersion[] = "nvmlSystemGetDriverVersion";
static const char __pyx_k_nvmlVgpuInstanceGetEccMode[] = "nvmlVgpuInstanceGetEccMode";
static const char __pyx_k_nvmlVgpuInstanceGetFbUsage[] = "nvmlVgpuInstanceGetFbUsage";
static const char __pyx_k_nvmlVgpuTypeGetGspHeapSize[] = "nvmlVgpuTypeGetGspHeapSize";
static const char __pyx_k_nvmlDeviceCreateGpuInstance[] = "nvmlDeviceCreateGpuInstance";
static const char __pyx_k_nvmlDeviceGetAPIRestriction[] = "nvmlDeviceGetAPIRestriction";
static const char __pyx_k_nvmlDeviceGetAccountingMode[] = "nvmlDeviceGetAccountingMode";
static const char __pyx_k_nvmlDeviceGetAccountingPids[] = "nvmlDeviceGetAccountingPids";
static const char __pyx_k_nvmlDeviceGetAddressingMode[] = "nvmlDeviceGetAddressingMode";
static const char __pyx_k_nvmlDeviceGetBAR1MemoryInfo[] = "nvmlDeviceGetBAR1MemoryInfo";
static const char __pyx_k_nvmlDeviceGetBridgeChipInfo[] = "nvmlDeviceGetBridgeChipInfo";
static const char __pyx_k_nvmlDeviceGetCreatableVgpus[] = "nvmlDeviceGetCreatableVgpus";
static const char __pyx_k_nvmlDeviceGetDefaultEccMode[] = "nvmlDeviceGetDefaultEccMode";
static const char __pyx_k_nvmlDeviceGetDriverModel_v2[] = "nvmlDeviceGetDriverModel_v2";
static const char __pyx_k_nvmlDeviceGetGpcClkVfOffset[] = "nvmlDeviceGetGpcClkVfOffset";
static const char __pyx_k_nvmlDeviceGetGpuFabricInfoV[] = "nvmlDeviceGetGpuFabricInfoV";
static const char __pyx_k_nvmlDeviceGetHandleBySerial[] = "nvmlDeviceGetHandleBySerial";
static const char __pyx_k_nvmlDeviceGetInforomVersion[] = "nvmlDeviceGetInforomVersion";
static const char __pyx_k_nvmlDeviceGetJpgUtilization[] = "nvmlDeviceGetJpgUtilization";
static const char __pyx_k_nvmlDeviceGetMemClkVfOffset[] = "nvmlDeviceGetMemClkVfOffset";
static const char __pyx_k_nvmlDeviceGetMemoryAffinity[] = "nvmlDeviceGetMemoryAffinity";
static const char __pyx_k_nvmlDeviceGetMemoryBusWidth[] = "nvmlDeviceGetMemoryBusWidth";
static const char __pyx_k_nvmlDeviceGetMinMaxFanSpeed[] = "nvmlDeviceGetMinMaxFanSpeed";
static const char __pyx_k_nvmlDeviceGetOfaUtilization[] = "nvmlDeviceGetOfaUtilization";
static const char __pyx_k_nvmlDeviceGetPcieThroughput[] = "nvmlDeviceGetPcieThroughput";
static const char __pyx_k_nvmlDeviceGetSupportedVgpus[] = "nvmlDeviceGetSupportedVgpus";
static const char __pyx_k_nvmlDeviceGetTargetFanSpeed[] = "nvmlDeviceGetTargetFanSpeed";
static const char __pyx_k_nvmlDeviceGetTotalEccErrors[] = "nvmlDeviceGetTotalEccErrors";
static const char __pyx_k_nvmlDeviceIsMigDeviceHandle[] = "nvmlDeviceIsMigDeviceHandle";
static const char __pyx_k_nvmlDeviceSetAPIRestriction[] = "nvmlDeviceSetAPIRestriction";
static const char __pyx_k_nvmlDeviceSetAccountingMode[] = "nvmlDeviceSetAccountingMode";
static const char __pyx_k_nvmlSystemGetTopologyGpuSet[] = "nvmlSystemGetTopologyGpuSet";
static const char __pyx_k_nvmlVgpuInstanceGetFBCStats[] = "nvmlVgpuInstanceGetFBCStats";
static const char __pyx_k_nvmlVgpuInstanceGetGpuPciId[] = "nvmlVgpuInstanceGetGpuPciId";
static const char __pyx_k_nvmlVgpuInstanceGetMdevUUID[] = "nvmlVgpuInstanceGetMdevUUID";
static const char __pyx_k_nvmlVgpuInstanceGetMetadata[] = "nvmlVgpuInstanceGetMetadata";
static const char __pyx_k_nvmlVgpuTypeGetCapabilities[] = "nvmlVgpuTypeGetCapabilities";
static const char __pyx_k_nvmlVgpuTypeGetMaxInstances[] = "nvmlVgpuTypeGetMaxInstances";
static const char __pyx_k_nvmlDeviceGetAccountingStats[] = "nvmlDeviceGetAccountingStats";
static const char __pyx_k_nvmlDeviceGetBoardPartNumber[] = "nvmlDeviceGetBoardPartNumber";
static const char __pyx_k_nvmlDeviceGetEncoderCapacity[] = "nvmlDeviceGetEncoderCapacity";
static const char __pyx_k_nvmlDeviceGetEncoderSessions[] = "nvmlDeviceGetEncoderSessions";
static const char __pyx_k_nvmlDeviceGetGpuInstanceById[] = "nvmlDeviceGetGpuInstanceById";
static const char __pyx_k_nvmlDeviceGetGspFirmwareMode[] = "nvmlDeviceGetGspFirmwareMode";
static const char __pyx_k_nvmlDeviceGetPersistenceMode[] = "nvmlDeviceGetPersistenceMode";
static const char __pyx_k_nvmlDeviceGetRetiredPages_v2[] = "nvmlDeviceGetRetiredPages_v2";
static const char __pyx_k_nvmlDeviceGetThermalSettings[] = "nvmlDeviceGetThermalSettings";
static const char __pyx_k_nvmlDeviceGetVgpuUtilization[] = "nvmlDeviceGetVgpuUtilization";
static const char __pyx_k_nvmlDeviceSetGpuLockedClocks[] = "nvmlDeviceSetGpuLockedClocks";
static const char __pyx_k_nvmlDeviceSetPersistenceMode[] = "nvmlDeviceSetPersistenceMode";
static const char __pyx_k_nvmlVgpuTypeGetFbReservation[] = "nvmlVgpuTypeGetFbReservation";
static const char __pyx_k_nvmlComputeInstanceGetInfo_v2[] = "nvmlComputeInstanceGetInfo_v2";
static const char __pyx_k_nvmlDeviceClearAccountingPids[] = "nvmlDeviceClearAccountingPids";
static const char __pyx_k_nvmlDeviceClearEccErrorCounts[] = "nvmlDeviceClearEccErrorCounts";
static const char __pyx_k_nvmlDeviceGetGpuOperationMode[] = "nvmlDeviceGetGpuOperationMode";
static const char __pyx_k_nvmlDeviceGetHandleByIndex_v2[] = "nvmlDeviceGetHandleByIndex_v2";
static const char __pyx_k_nvmlDeviceGetLastBBXFlushTime[] = "nvmlDeviceGetLastBBXFlushTime";
static const char __pyx_k_nvmlDeviceGetMaxPcieLinkWidth[] = "nvmlDeviceGetMaxPcieLinkWidth";
static const char __pyx_k_nvmlDeviceGetNvLinkCapability[] = "nvmlDeviceGetNvLinkCapability";
static const char __pyx_k_nvmlDeviceGetPcieLinkMaxSpeed[] = "nvmlDeviceGetPcieLinkMaxSpeed";
static const char __pyx_k_nvmlDeviceGetPerformanceModes[] = "nvmlDeviceGetPerformanceModes";
static const char __pyx_k_nvmlDeviceGetPerformanceState[] = "nvmlDeviceGetPerformanceState";
static const char __pyx_k_nvmlDeviceGetUtilizationRates[] = "nvmlDeviceGetUtilizationRates";
static const char __pyx_k_nvmlDeviceGetVgpuCapabilities[] = "nvmlDeviceGetVgpuCapabilities";
static const char __pyx_k_nvmlDeviceGetVgpuSchedulerLog[] = "nvmlDeviceGetVgpuSchedulerLog";
static const char __pyx_k_nvmlDeviceSetFanControlPolicy[] = "nvmlDeviceSetFanControlPolicy";
static const char __pyx_k_nvmlDeviceSetGpuOperationMode[] = "nvmlDeviceSetGpuOperationMode";
static const char __pyx_k_nvmlDeviceSetVgpuCapabilities[] = "nvmlDeviceSetVgpuCapabilities";
static const char __pyx_k_nvmlGetVgpuDriverCapabilities[] = "nvmlGetVgpuDriverCapabilities";
static const char __pyx_k_nvmlGpuInstanceGetActiveVgpus[] = "nvmlGpuInstanceGetActiveVgpus";
static const char __pyx_k_nvmlSystemGetConfComputeState[] = "nvmlSystemGetConfComputeState";
static const char __pyx_k_nvmlVgpuTypeGetFrameRateLimit[] = "nvmlVgpuTypeGetFrameRateLimit";
static const char __pyx_k_nvmlDeviceGetComputeInstanceId[] = "nvmlDeviceGetComputeInstanceId";
static const char __pyx_k_nvmlDeviceGetCurrPcieLinkWidth[] = "nvmlDeviceGetCurrPcieLinkWidth";
static const char __pyx_k_nvmlDeviceGetCurrentClockFreqs[] = "nvmlDeviceGetCurrentClockFreqs";
static const char __pyx_k_nvmlDeviceGetMarginTemperature[] = "nvmlDeviceGetMarginTemperature";
static const char __pyx_k_nvmlDeviceGetMaxMigDeviceCount[] = "nvmlDeviceGetMaxMigDeviceCount";
static const char __pyx_k_nvmlDeviceGetPcieReplayCounter[] = "nvmlDeviceGetPcieReplayCounter";
static const char __pyx_k_nvmlDeviceGetPowerMizerMode_v1[] = "nvmlDeviceGetPowerMizerMode_v1";
static const char __pyx_k_nvmlDeviceResetGpuLockedClocks[] = "nvmlDeviceResetGpuLockedClocks";
static const char __pyx_k_nvmlDeviceSetPowerMizerMode_v1[] = "nvmlDeviceSetPowerMizerMode_v1";
static const char __pyx_k_nvmlGpmQueryIfStreamingEnabled[] = "nvmlGpmQueryIfStreamingEnabled";
static const char __pyx_k_nvmlSystemGetCudaDriverVersion[] = "nvmlSystemGetCudaDriverVersion";
static const char __pyx_k_nvmlVgpuInstanceGetFBCSessions[] = "nvmlVgpuInstanceGetFBCSessions";
static const char __pyx_k_nvmlVgpuInstanceGetPlacementId[] = "nvmlVgpuInstanceGetPlacementId";
static const char __pyx_k_nvmlVgpuTypeGetFramebufferSize[] = "nvmlVgpuTypeGetFramebufferSize";
static const char __pyx_k_nvmlVgpuTypeGetNumDisplayHeads[] = "nvmlVgpuTypeGetNumDisplayHeads";
static const char __pyx_k_nvmlDeviceGetDecoderUtilization[] = "nvmlDeviceGetDecoderUtilization";
static const char __pyx_k_nvmlDeviceGetDramEncryptionMode[] = "nvmlDeviceGetDramEncryptionMode";
static const char __pyx_k_nvmlDeviceGetDynamicPstatesInfo[] = "nvmlDeviceGetDynamicPstatesInfo";
static const char __pyx_k_nvmlDeviceGetEncoderUtilization[] = "nvmlDeviceGetEncoderUtilization";
static const char __pyx_k_nvmlDeviceGetEnforcedPowerLimit[] = "nvmlDeviceGetEnforcedPowerLimit";
static const char __pyx_k_nvmlDeviceGetGspFirmwareVersion[] = "nvmlDeviceGetGspFirmwareVersion";
static const char __pyx_k_nvmlDeviceGetMemoryErrorCounter[] = "nvmlDeviceGetMemoryErrorCounter";
static const char __pyx_k_nvmlDeviceGetNvLinkErrorCounter[] = "nvmlDeviceGetNvLinkErrorCounter";
static const char __pyx_k_nvmlDeviceGetPgpuMetadataString[] = "nvmlDeviceGetPgpuMetadataString";
static const char __pyx_k_nvmlDeviceGetProcessUtilization[] = "nvmlDeviceGetProcessUtilization";
static const char __pyx_k_nvmlDeviceGetSramEccErrorStatus[] = "nvmlDeviceGetSramEccErrorStatus";
static const char __pyx_k_nvmlDeviceGetVgpuSchedulerState[] = "nvmlDeviceGetVgpuSchedulerState";
static const char __pyx_k_nvmlDeviceGetVirtualizationMode[] = "nvmlDeviceGetVirtualizationMode";
static const char __pyx_k_nvmlDeviceSetDefaultFanSpeed_v2[] = "nvmlDeviceSetDefaultFanSpeed_v2";
static const char __pyx_k_nvmlDeviceSetDramEncryptionMode[] = "nvmlDeviceSetDramEncryptionMode";
static const char __pyx_k_nvmlDeviceSetMemoryLockedClocks[] = "nvmlDeviceSetMemoryLockedClocks";
static const char __pyx_k_nvmlDeviceSetVgpuSchedulerState[] = "nvmlDeviceSetVgpuSchedulerState";
static const char __pyx_k_nvmlDeviceSetVirtualizationMode[] = "nvmlDeviceSetVirtualizationMode";
static const char __pyx_k_nvmlVgpuInstanceGetEncoderStats[] = "nvmlVgpuInstanceGetEncoderStats";
static const char __pyx_k_nvmlDeviceCreateGpuInstanceWithP[] = "nvmlDeviceCreateGpuInstanceWithPlacement";
static const char __pyx_k_nvmlDeviceGetAccountingBufferSiz[] = "nvmlDeviceGetAccountingBufferSize";
static const char __pyx_k_nvmlDeviceGetAdaptiveClockInfoSt[] = "nvmlDeviceGetAdaptiveClockInfoStatus";
static const char __pyx_k_nvmlDeviceGetAutoBoostedClocksEn[] = "nvmlDeviceGetAutoBoostedClocksEnabled";
static const char __pyx_k_nvmlDeviceGetComputeRunningProce[] = "nvmlDeviceGetComputeRunningProcesses_v3";
static const char __pyx_k_nvmlDeviceGetConfComputeGpuAttes[] = "nvmlDeviceGetConfComputeGpuAttestationReport";
static const char __pyx_k_nvmlDeviceGetConfComputeGpuCerti[] = "nvmlDeviceGetConfComputeGpuCertificate";
static const char __pyx_k_nvmlDeviceGetConfComputeMemSizeI[] = "nvmlDeviceGetConfComputeMemSizeInfo";
static const char __pyx_k_nvmlDeviceGetConfComputeProtecte[] = "nvmlDeviceGetConfComputeProtectedMemoryUsage";
static const char __pyx_k_nvmlDeviceGetCpuAffinityWithinSc[] = "nvmlDeviceGetCpuAffinityWithinScope";
static const char __pyx_k_nvmlDeviceGetCudaComputeCapabili[] = "nvmlDeviceGetCudaComputeCapability";
static const char __pyx_k_nvmlDeviceGetCurrPcieLinkGenerat[] = "nvmlDeviceGetCurrPcieLinkGeneration";
static const char __pyx_k_nvmlDeviceGetCurrentClocksEventR[] = "nvmlDeviceGetCurrentClocksEventReasons";
static const char __pyx_k_nvmlDeviceGetDeviceHandleFromMig[] = "nvmlDeviceGetDeviceHandleFromMigDeviceHandle";
static const char __pyx_k_nvmlDeviceGetFanControlPolicy_v2[] = "nvmlDeviceGetFanControlPolicy_v2";
static const char __pyx_k_nvmlDeviceGetGpcClkMinMaxVfOffse[] = "nvmlDeviceGetGpcClkMinMaxVfOffset";
static const char __pyx_k_nvmlDeviceGetGpuInstancePossible[] = "nvmlDeviceGetGpuInstancePossiblePlacements_v2";
static const char __pyx_k_nvmlDeviceGetGpuInstanceProfileI[] = "nvmlDeviceGetGpuInstanceProfileInfoV";
static const char __pyx_k_nvmlDeviceGetGpuInstanceRemainin[] = "nvmlDeviceGetGpuInstanceRemainingCapacity";
static const char __pyx_k_nvmlDeviceGetGpuMaxPcieLinkGener[] = "nvmlDeviceGetGpuMaxPcieLinkGeneration";
static const char __pyx_k_nvmlDeviceGetGridLicensableFeatu[] = "nvmlDeviceGetGridLicensableFeatures_v4";
static const char __pyx_k_nvmlDeviceGetHandleByPciBusId_v2[] = "nvmlDeviceGetHandleByPciBusId_v2";
static const char __pyx_k_nvmlDeviceGetInforomConfiguratio[] = "nvmlDeviceGetInforomConfigurationChecksum";
static const char __pyx_k_nvmlDeviceGetInforomImageVersion[] = "nvmlDeviceGetInforomImageVersion";
static const char __pyx_k_nvmlDeviceGetMPSComputeRunningPr[] = "nvmlDeviceGetMPSComputeRunningProcesses_v3";
static const char __pyx_k_nvmlDeviceGetMaxCustomerBoostClo[] = "nvmlDeviceGetMaxCustomerBoostClock";
static const char __pyx_k_nvmlDeviceGetMaxPcieLinkGenerati[] = "nvmlDeviceGetMaxPcieLinkGeneration";
static const char __pyx_k_nvmlDeviceGetMemClkMinMaxVfOffse[] = "nvmlDeviceGetMemClkMinMaxVfOffset";
static const char __pyx_k_nvmlDeviceGetMigDeviceHandleByIn[] = "nvmlDeviceGetMigDeviceHandleByIndex";
static const char __pyx_k_nvmlDeviceGetMinMaxClockOfPState[] = "nvmlDeviceGetMinMaxClockOfPState";
static const char __pyx_k_nvmlDeviceGetNvLinkRemoteDeviceT[] = "nvmlDeviceGetNvLinkRemoteDeviceType";
static const char __pyx_k_nvmlDeviceGetNvLinkRemotePciInfo[] = "nvmlDeviceGetNvLinkRemotePciInfo_v2";
static const char __pyx_k_nvmlDeviceGetNvlinkSupportedBwMo[] = "nvmlDeviceGetNvlinkSupportedBwModes";
static const char __pyx_k_nvmlDeviceGetPowerManagementDefa[] = "nvmlDeviceGetPowerManagementDefaultLimit";
static const char __pyx_k_nvmlDeviceGetPowerManagementLimi[] = "nvmlDeviceGetPowerManagementLimit";
static const char __pyx_k_nvmlDeviceGetProcessesUtilizatio[] = "nvmlDeviceGetProcessesUtilizationInfo";
static const char __pyx_k_nvmlDeviceGetRetiredPagesPending[] = "nvmlDeviceGetRetiredPagesPendingStatus";
static const char __pyx_k_nvmlDeviceGetRowRemapperHistogra[] = "nvmlDeviceGetRowRemapperHistogram";
static const char __pyx_k_nvmlDeviceGetRunningProcessDetai[] = "nvmlDeviceGetRunningProcessDetailList";
static const char __pyx_k_nvmlDeviceGetSramUniqueUncorrect[] = "nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts";
static const char __pyx_k_nvmlDeviceGetSupportedClocksEven[] = "nvmlDeviceGetSupportedClocksEventReasons";
static const char __pyx_k_nvmlDeviceGetSupportedEventTypes[] = "nvmlDeviceGetSupportedEventTypes";
static const char __pyx_k_nvmlDeviceGetSupportedGraphicsCl[] = "nvmlDeviceGetSupportedGraphicsClocks";
static const char __pyx_k_nvmlDeviceGetSupportedMemoryCloc[] = "nvmlDeviceGetSupportedMemoryClocks";
static const char __pyx_k_nvmlDeviceGetSupportedPerformanc[] = "nvmlDeviceGetSupportedPerformanceStates";
static const char __pyx_k_nvmlDeviceGetTemperatureThreshol[] = "nvmlDeviceGetTemperatureThreshold";
static const char __pyx_k_nvmlDeviceGetTopologyCommonAnces[] = "nvmlDeviceGetTopologyCommonAncestor";
static const char __pyx_k_nvmlDeviceGetTopologyNearestGpus[] = "nvmlDeviceGetTopologyNearestGpus";
static const char __pyx_k_nvmlDeviceGetTotalEnergyConsumpt[] = "nvmlDeviceGetTotalEnergyConsumption";
static const char __pyx_k_nvmlDeviceGetVgpuHeterogeneousMo[] = "nvmlDeviceGetVgpuHeterogeneousMode";
static const char __pyx_k_nvmlDeviceGetVgpuInstancesUtiliz[] = "nvmlDeviceGetVgpuInstancesUtilizationInfo";
static const char __pyx_k_nvmlDeviceGetVgpuProcessUtilizat[] = "nvmlDeviceGetVgpuProcessUtilization";
static const char __pyx_k_nvmlDeviceGetVgpuProcessesUtiliz[] = "nvmlDeviceGetVgpuProcessesUtilizationInfo";
static const char __pyx_k_nvmlDeviceGetVgpuSchedulerCapabi[] = "nvmlDeviceGetVgpuSchedulerCapabilities";
static const char __pyx_k_nvmlDeviceGetVgpuTypeCreatablePl[] = "nvmlDeviceGetVgpuTypeCreatablePlacements";
static const char __pyx_k_nvmlDeviceGetVgpuTypeSupportedPl[] = "nvmlDeviceGetVgpuTypeSupportedPlacements";
static const char __pyx_k_nvmlDevicePowerSmoothingActivate[] = "nvmlDevicePowerSmoothingActivatePresetProfile";
static const char __pyx_k_nvmlDevicePowerSmoothingSetState[] = "nvmlDevicePowerSmoothingSetState";
static const char __pyx_k_nvmlDevicePowerSmoothingUpdatePr[] = "nvmlDevicePowerSmoothingUpdatePresetProfileParam";
static const char __pyx_k_nvmlDeviceResetMemoryLockedClock[] = "nvmlDeviceResetMemoryLockedClocks";
static const char __pyx_k_nvmlDeviceResetNvLinkErrorCounte[] = "nvmlDeviceResetNvLinkErrorCounters";
static const char __pyx_k_nvmlDeviceSetAutoBoostedClocksEn[] = "nvmlDeviceSetAutoBoostedClocksEnabled";
static const char __pyx_k_nvmlDeviceSetConfComputeUnprotec[] = "nvmlDeviceSetConfComputeUnprotectedMemSize";
static const char __pyx_k_nvmlDeviceSetDefaultAutoBoostedC[] = "nvmlDeviceSetDefaultAutoBoostedClocksEnabled";
static const char __pyx_k_nvmlDeviceSetNvLinkDeviceLowPowe[] = "nvmlDeviceSetNvLinkDeviceLowPowerThreshold";
static const char __pyx_k_nvmlDeviceSetPowerManagementLimi[] = "nvmlDeviceSetPowerManagementLimit";
static const char __pyx_k_nvmlDeviceSetTemperatureThreshol[] = "nvmlDeviceSetTemperatureThreshold";
static const char __pyx_k_nvmlDeviceSetVgpuHeterogeneousMo[] = "nvmlDeviceSetVgpuHeterogeneousMode";
static const char __pyx_k_nvmlDeviceWorkloadPowerProfileCl[] = "nvmlDeviceWorkloadPowerProfileClearRequestedProfiles";
static const char __pyx_k_nvmlGetExcludedDeviceInfoByIndex[] = "nvmlGetExcludedDeviceInfoByIndex";
static const char __pyx_k_nvmlGpuInstanceCreateComputeInst[] = "nvmlGpuInstanceCreateComputeInstance";
static const char __pyx_k_nvmlGpuInstanceGetComputeInstanc[] = "nvmlGpuInstanceGetComputeInstanceProfileInfoV";
static const char __pyx_k_nvmlGpuInstanceGetCreatableVgpus[] = "nvmlGpuInstanceGetCreatableVgpus";
static const char __pyx_k_nvmlGpuInstanceGetVgpuHeterogene[] = "nvmlGpuInstanceGetVgpuHeterogeneousMode";
static const char __pyx_k_nvmlGpuInstanceGetVgpuSchedulerL[] = "nvmlGpuInstanceGetVgpuSchedulerLog";
static const char __pyx_k_nvmlGpuInstanceGetVgpuSchedulerS[] = "nvmlGpuInstanceGetVgpuSchedulerState";
static const char __pyx_k_nvmlGpuInstanceGetVgpuTypeCreata[] = "nvmlGpuInstanceGetVgpuTypeCreatablePlacements";
static const char __pyx_k_nvmlGpuInstanceSetVgpuHeterogene[] = "nvmlGpuInstanceSetVgpuHeterogeneousMode";
static const char __pyx_k_nvmlGpuInstanceSetVgpuSchedulerS[] = "nvmlGpuInstanceSetVgpuSchedulerState";
static const char __pyx_k_nvmlSystemGetConfComputeCapabili[] = "nvmlSystemGetConfComputeCapabilities";
static const char __pyx_k_nvmlSystemGetConfComputeGpusRead[] = "nvmlSystemGetConfComputeGpusReadyState";
static const char __pyx_k_nvmlSystemGetConfComputeKeyRotat[] = "nvmlSystemGetConfComputeKeyRotationThresholdInfo";
static const char __pyx_k_nvmlSystemGetConfComputeSettings[] = "nvmlSystemGetConfComputeSettings";
static const char __pyx_k_nvmlSystemGetCudaDriverVersion_v[] = "nvmlSystemGetCudaDriverVersion_v2";
static const char __pyx_k_nvmlSystemSetConfComputeGpusRead[] = "nvmlSystemSetConfComputeGpusReadyState";
static const char __pyx_k_nvmlSystemSetConfComputeKeyRotat[] = "nvmlSystemSetConfComputeKeyRotationThresholdInfo";
static const char __pyx_k_nvmlVgpuInstanceClearAccountingP[] = "nvmlVgpuInstanceClearAccountingPids";
static const char __pyx_k_nvmlVgpuInstanceGetAccountingMod[] = "nvmlVgpuInstanceGetAccountingMode";
static const char __pyx_k_nvmlVgpuInstanceGetAccountingPid[] = "nvmlVgpuInstanceGetAccountingPids";
static const char __pyx_k_nvmlVgpuInstanceGetAccountingSta[] = "nvmlVgpuInstanceGetAccountingStats";
static const char __pyx_k_nvmlVgpuInstanceGetEncoderCapaci[] = "nvmlVgpuInstanceGetEncoderCapacity";
static const char __pyx_k_nvmlVgpuInstanceGetEncoderSessio[] = "nvmlVgpuInstanceGetEncoderSessions";
static const char __pyx_k_nvmlVgpuInstanceGetFrameRateLimi[] = "nvmlVgpuInstanceGetFrameRateLimit";
static const char __pyx_k_nvmlVgpuInstanceGetGpuInstanceId[] = "nvmlVgpuInstanceGetGpuInstanceId";
static const char __pyx_k_nvmlVgpuInstanceGetLicenseInfo_v[] = "nvmlVgpuInstanceGetLicenseInfo_v2";
static const char __pyx_k_nvmlVgpuInstanceGetLicenseStatus[] = "nvmlVgpuInstanceGetLicenseStatus";
static const char __pyx_k_nvmlVgpuInstanceGetRuntimeStateS[] = "nvmlVgpuInstanceGetRuntimeStateSize";
static const char __pyx_k_nvmlVgpuInstanceGetVmDriverVersi[] = "nvmlVgpuInstanceGetVmDriverVersion";
static const char __pyx_k_nvmlVgpuInstanceSetEncoderCapaci[] = "nvmlVgpuInstanceSetEncoderCapacity";
static const char __pyx_k_nvmlVgpuTypeGetGpuInstanceProfil[] = "nvmlVgpuTypeGetGpuInstanceProfileId";
static const char __pyx_k_nvmlVgpuTypeGetMaxInstancesPerGp[] = "nvmlVgpuTypeGetMaxInstancesPerGpuInstance";
static const char __pyx_k_nvmlVgpuTypeGetMaxInstancesPerVm[] = "nvmlVgpuTypeGetMaxInstancesPerVm";
static const char __pyx_k_nvmlDeviceGetGpuInstanceProfileI_2[] = "nvmlDeviceGetGpuInstanceProfileInfoByIdV";
static const char __pyx_k_nvmlDeviceGetPowerManagementLimi_2[] = "nvmlDeviceGetPowerManagementLimitConstraints";
static const char __pyx_k_nvmlDeviceSetPowerManagementLimi_2[] = "nvmlDeviceSetPowerManagementLimit_v2";
static const char __pyx_k_nvmlGpuInstanceCreateComputeInst_2[] = "nvmlGpuInstanceCreateComputeInstanceWithPlacement";
static const char __pyx_k_nvmlGpuInstanceGetComputeInstanc_2[] = "nvmlGpuInstanceGetComputeInstanceRemainingCapacity";
static const char __pyx_k_nvmlGpuInstanceGetComputeInstanc_3[] = "nvmlGpuInstanceGetComputeInstancePossiblePlacements";
static const char __pyx_k_nvmlGpuInstanceGetComputeInstanc_4[] = "nvmlGpuInstanceGetComputeInstances";
static const char __pyx_k_nvmlGpuInstanceGetComputeInstanc_5[] = "nvmlGpuInstanceGetComputeInstanceById";
/* #### Code section: decls ### */
static PyObject *__pyx_pf_4cuda_8bindings_9_internal_5_nvml__inspect_function_pointers(CYTHON_UNUSED PyObject *__pyx_self); /* proto */
static PyObject *__pyx_pf_4cuda_8bindings_9_internal_5_nvml_2_inspect_function_pointer(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_name); /* proto */
/* #### Code section: late_includes ### */
/* #### Code section: module_state ### */
/* SmallCodeConfig */
#ifndef CYTHON_SMALL_CODE
#if defined(__clang__)
    #define CYTHON_SMALL_CODE
#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
    #define CYTHON_SMALL_CODE __attribute__((cold))
#else
    #define CYTHON_SMALL_CODE
#endif
#endif

typedef struct {
  PyObject *__pyx_d;
  PyObject *__pyx_b;
  PyObject *__pyx_cython_runtime;
  PyObject *__pyx_empty_tuple;
  PyObject *__pyx_empty_bytes;
  PyObject *__pyx_empty_unicode;
  __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_items;
  __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_pop;
  __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_values;
  PyObject *__pyx_tuple[1];
  PyObject *__pyx_codeobj_tab[2];
  PyObject *__pyx_string_tab[736];
/* #### Code section: module_state_contents ### */
/* CommonTypesMetaclass.module_state_decls */
PyTypeObject *__pyx_CommonTypesMetaclassType;

/* CachedMethodType.module_state_decls */
#if CYTHON_COMPILING_IN_LIMITED_API
PyObject *__Pyx_CachedMethodType;
#endif

/* CythonFunctionShared.module_state_decls */
PyTypeObject *__pyx_CyFunctionType;

/* CodeObjectCache.module_state_decls */
struct __Pyx_CodeObjectCache __pyx_code_cache;

/* #### Code section: module_state_end ### */
} __pyx_mstatetype;

#if CYTHON_USE_MODULE_STATE
#ifdef __cplusplus
namespace {
extern struct PyModuleDef __pyx_moduledef;
} /* anonymous namespace */
#else
static struct PyModuleDef __pyx_moduledef;
#endif

#define __pyx_mstate_global (__Pyx_PyModule_GetState(__Pyx_State_FindModule(&__pyx_moduledef)))

#define __pyx_m (__Pyx_State_FindModule(&__pyx_moduledef))
#else
static __pyx_mstatetype __pyx_mstate_global_static =
#ifdef __cplusplus
    {};
#else
    {0};
#endif
static __pyx_mstatetype * const __pyx_mstate_global = &__pyx_mstate_global_static;
#endif
/* #### Code section: constant_name_defines ### */
#define __pyx_kp_u_ __pyx_string_tab[0]
#define __pyx_kp_u_CUDA_driver_is_not_found __pyx_string_tab[1]
#define __pyx_kp_u_Did_not_find_cuDriverGetVersion __pyx_string_tab[2]
#define __pyx_kp_u_Note_that_Cython_is_deliberately __pyx_string_tab[3]
#define __pyx_kp_u__2 __pyx_string_tab[4]
#define __pyx_kp_u__3 __pyx_string_tab[5]
#define __pyx_kp_u_add_note __pyx_string_tab[6]
#define __pyx_kp_u_cuDriverGetVersion_returned_erro __pyx_string_tab[7]
#define __pyx_kp_u_cuda_bindings__internal__nvml_py __pyx_string_tab[8]
#define __pyx_kp_u_cuda_bindings__internal_utils __pyx_string_tab[9]
#define __pyx_kp_u_function_nvmlComputeInstanceDest __pyx_string_tab[10]
#define __pyx_kp_u_function_nvmlComputeInstanceGetI __pyx_string_tab[11]
#define __pyx_kp_u_function_nvmlDeviceClearAccounti __pyx_string_tab[12]
#define __pyx_kp_u_function_nvmlDeviceClearCpuAffin __pyx_string_tab[13]
#define __pyx_kp_u_function_nvmlDeviceClearEccError __pyx_string_tab[14]
#define __pyx_kp_u_function_nvmlDeviceClearFieldVal __pyx_string_tab[15]
#define __pyx_kp_u_function_nvmlDeviceCreateGpuInst __pyx_string_tab[16]
#define __pyx_kp_u_function_nvmlDeviceCreateGpuInst_2 __pyx_string_tab[17]
#define __pyx_kp_u_function_nvmlDeviceDiscoverGpus __pyx_string_tab[18]
#define __pyx_kp_u_function_nvmlDeviceGetAPIRestric __pyx_string_tab[19]
#define __pyx_kp_u_function_nvmlDeviceGetAccounting __pyx_string_tab[20]
#define __pyx_kp_u_function_nvmlDeviceGetAccounting_2 __pyx_string_tab[21]
#define __pyx_kp_u_function_nvmlDeviceGetAccounting_3 __pyx_string_tab[22]
#define __pyx_kp_u_function_nvmlDeviceGetAccounting_4 __pyx_string_tab[23]
#define __pyx_kp_u_function_nvmlDeviceGetActiveVgpu __pyx_string_tab[24]
#define __pyx_kp_u_function_nvmlDeviceGetAdaptiveCl __pyx_string_tab[25]
#define __pyx_kp_u_function_nvmlDeviceGetAddressing __pyx_string_tab[26]
#define __pyx_kp_u_function_nvmlDeviceGetArchitectu __pyx_string_tab[27]
#define __pyx_kp_u_function_nvmlDeviceGetAttributes __pyx_string_tab[28]
#define __pyx_kp_u_function_nvmlDeviceGetAutoBooste __pyx_string_tab[29]
#define __pyx_kp_u_function_nvmlDeviceGetBAR1Memory __pyx_string_tab[30]
#define __pyx_kp_u_function_nvmlDeviceGetBoardId_is __pyx_string_tab[31]
#define __pyx_kp_u_function_nvmlDeviceGetBoardPartN __pyx_string_tab[32]
#define __pyx_kp_u_function_nvmlDeviceGetBrand_is_n __pyx_string_tab[33]
#define __pyx_kp_u_function_nvmlDeviceGetBridgeChip __pyx_string_tab[34]
#define __pyx_kp_u_function_nvmlDeviceGetBusType_is __pyx_string_tab[35]
#define __pyx_kp_u_function_nvmlDeviceGetC2cModeInf __pyx_string_tab[36]
#define __pyx_kp_u_function_nvmlDeviceGetCapabiliti __pyx_string_tab[37]
#define __pyx_kp_u_function_nvmlDeviceGetClkMonStat __pyx_string_tab[38]
#define __pyx_kp_u_function_nvmlDeviceGetClockInfo __pyx_string_tab[39]
#define __pyx_kp_u_function_nvmlDeviceGetClockOffse __pyx_string_tab[40]
#define __pyx_kp_u_function_nvmlDeviceGetClock_is_n __pyx_string_tab[41]
#define __pyx_kp_u_function_nvmlDeviceGetComputeIns __pyx_string_tab[42]
#define __pyx_kp_u_function_nvmlDeviceGetComputeMod __pyx_string_tab[43]
#define __pyx_kp_u_function_nvmlDeviceGetComputeRun __pyx_string_tab[44]
#define __pyx_kp_u_function_nvmlDeviceGetConfComput __pyx_string_tab[45]
#define __pyx_kp_u_function_nvmlDeviceGetConfComput_2 __pyx_string_tab[46]
#define __pyx_kp_u_function_nvmlDeviceGetConfComput_3 __pyx_string_tab[47]
#define __pyx_kp_u_function_nvmlDeviceGetConfComput_4 __pyx_string_tab[48]
#define __pyx_kp_u_function_nvmlDeviceGetCoolerInfo __pyx_string_tab[49]
#define __pyx_kp_u_function_nvmlDeviceGetCount_v2_i __pyx_string_tab[50]
#define __pyx_kp_u_function_nvmlDeviceGetCpuAffinit __pyx_string_tab[51]
#define __pyx_kp_u_function_nvmlDeviceGetCpuAffinit_2 __pyx_string_tab[52]
#define __pyx_kp_u_function_nvmlDeviceGetCreatableV __pyx_string_tab[53]
#define __pyx_kp_u_function_nvmlDeviceGetCudaComput __pyx_string_tab[54]
#define __pyx_kp_u_function_nvmlDeviceGetCurrPcieLi __pyx_string_tab[55]
#define __pyx_kp_u_function_nvmlDeviceGetCurrPcieLi_2 __pyx_string_tab[56]
#define __pyx_kp_u_function_nvmlDeviceGetCurrentClo __pyx_string_tab[57]
#define __pyx_kp_u_function_nvmlDeviceGetCurrentClo_2 __pyx_string_tab[58]
#define __pyx_kp_u_function_nvmlDeviceGetDecoderUti __pyx_string_tab[59]
#define __pyx_kp_u_function_nvmlDeviceGetDefaultEcc __pyx_string_tab[60]
#define __pyx_kp_u_function_nvmlDeviceGetDeviceHand __pyx_string_tab[61]
#define __pyx_kp_u_function_nvmlDeviceGetDisplayAct __pyx_string_tab[62]
#define __pyx_kp_u_function_nvmlDeviceGetDisplayMod __pyx_string_tab[63]
#define __pyx_kp_u_function_nvmlDeviceGetDramEncryp __pyx_string_tab[64]
#define __pyx_kp_u_function_nvmlDeviceGetDriverMode __pyx_string_tab[65]
#define __pyx_kp_u_function_nvmlDeviceGetDynamicPst __pyx_string_tab[66]
#define __pyx_kp_u_function_nvmlDeviceGetEccMode_is __pyx_string_tab[67]
#define __pyx_kp_u_function_nvmlDeviceGetEncoderCap __pyx_string_tab[68]
#define __pyx_kp_u_function_nvmlDeviceGetEncoderSes __pyx_string_tab[69]
#define __pyx_kp_u_function_nvmlDeviceGetEncoderSta __pyx_string_tab[70]
#define __pyx_kp_u_function_nvmlDeviceGetEncoderUti __pyx_string_tab[71]
#define __pyx_kp_u_function_nvmlDeviceGetEnforcedPo __pyx_string_tab[72]
#define __pyx_kp_u_function_nvmlDeviceGetFBCSession __pyx_string_tab[73]
#define __pyx_kp_u_function_nvmlDeviceGetFBCStats_i __pyx_string_tab[74]
#define __pyx_kp_u_function_nvmlDeviceGetFanControl __pyx_string_tab[75]
#define __pyx_kp_u_function_nvmlDeviceGetFanSpeedRP __pyx_string_tab[76]
#define __pyx_kp_u_function_nvmlDeviceGetFanSpeed_i __pyx_string_tab[77]
#define __pyx_kp_u_function_nvmlDeviceGetFanSpeed_v __pyx_string_tab[78]
#define __pyx_kp_u_function_nvmlDeviceGetFieldValue __pyx_string_tab[79]
#define __pyx_kp_u_function_nvmlDeviceGetGpcClkMinM __pyx_string_tab[80]
#define __pyx_kp_u_function_nvmlDeviceGetGpcClkVfOf __pyx_string_tab[81]
#define __pyx_kp_u_function_nvmlDeviceGetGpuFabricI __pyx_string_tab[82]
#define __pyx_kp_u_function_nvmlDeviceGetGpuInstanc __pyx_string_tab[83]
#define __pyx_kp_u_function_nvmlDeviceGetGpuInstanc_2 __pyx_string_tab[84]
#define __pyx_kp_u_function_nvmlDeviceGetGpuInstanc_3 __pyx_string_tab[85]
#define __pyx_kp_u_function_nvmlDeviceGetGpuInstanc_4 __pyx_string_tab[86]
#define __pyx_kp_u_function_nvmlDeviceGetGpuInstanc_5 __pyx_string_tab[87]
#define __pyx_kp_u_function_nvmlDeviceGetGpuInstanc_6 __pyx_string_tab[88]
#define __pyx_kp_u_function_nvmlDeviceGetGpuInstanc_7 __pyx_string_tab[89]
#define __pyx_kp_u_function_nvmlDeviceGetGpuMaxPcie __pyx_string_tab[90]
#define __pyx_kp_u_function_nvmlDeviceGetGpuOperati __pyx_string_tab[91]
#define __pyx_kp_u_function_nvmlDeviceGetGridLicens __pyx_string_tab[92]
#define __pyx_kp_u_function_nvmlDeviceGetGspFirmwar __pyx_string_tab[93]
#define __pyx_kp_u_function_nvmlDeviceGetGspFirmwar_2 __pyx_string_tab[94]
#define __pyx_kp_u_function_nvmlDeviceGetHandleByIn __pyx_string_tab[95]
#define __pyx_kp_u_function_nvmlDeviceGetHandleByPc __pyx_string_tab[96]
#define __pyx_kp_u_function_nvmlDeviceGetHandleBySe __pyx_string_tab[97]
#define __pyx_kp_u_function_nvmlDeviceGetHandleByUU __pyx_string_tab[98]
#define __pyx_kp_u_function_nvmlDeviceGetHandleByUU_2 __pyx_string_tab[99]
#define __pyx_kp_u_function_nvmlDeviceGetHostVgpuMo __pyx_string_tab[100]
#define __pyx_kp_u_function_nvmlDeviceGetHostname_v __pyx_string_tab[101]
#define __pyx_kp_u_function_nvmlDeviceGetIndex_is_n __pyx_string_tab[102]
#define __pyx_kp_u_function_nvmlDeviceGetInforomCon __pyx_string_tab[103]
#define __pyx_kp_u_function_nvmlDeviceGetInforomIma __pyx_string_tab[104]
#define __pyx_kp_u_function_nvmlDeviceGetInforomVer __pyx_string_tab[105]
#define __pyx_kp_u_function_nvmlDeviceGetIrqNum_is __pyx_string_tab[106]
#define __pyx_kp_u_function_nvmlDeviceGetJpgUtiliza __pyx_string_tab[107]
#define __pyx_kp_u_function_nvmlDeviceGetLastBBXFlu __pyx_string_tab[108]
#define __pyx_kp_u_function_nvmlDeviceGetMPSCompute __pyx_string_tab[109]
#define __pyx_kp_u_function_nvmlDeviceGetMarginTemp __pyx_string_tab[110]
#define __pyx_kp_u_function_nvmlDeviceGetMaxClockIn __pyx_string_tab[111]
#define __pyx_kp_u_function_nvmlDeviceGetMaxCustome __pyx_string_tab[112]
#define __pyx_kp_u_function_nvmlDeviceGetMaxMigDevi __pyx_string_tab[113]
#define __pyx_kp_u_function_nvmlDeviceGetMaxPcieLin __pyx_string_tab[114]
#define __pyx_kp_u_function_nvmlDeviceGetMaxPcieLin_2 __pyx_string_tab[115]
#define __pyx_kp_u_function_nvmlDeviceGetMemClkMinM __pyx_string_tab[116]
#define __pyx_kp_u_function_nvmlDeviceGetMemClkVfOf __pyx_string_tab[117]
#define __pyx_kp_u_function_nvmlDeviceGetMemoryAffi __pyx_string_tab[118]
#define __pyx_kp_u_function_nvmlDeviceGetMemoryBusW __pyx_string_tab[119]
#define __pyx_kp_u_function_nvmlDeviceGetMemoryErro __pyx_string_tab[120]
#define __pyx_kp_u_function_nvmlDeviceGetMemoryInfo __pyx_string_tab[121]
#define __pyx_kp_u_function_nvmlDeviceGetMigDeviceH __pyx_string_tab[122]
#define __pyx_kp_u_function_nvmlDeviceGetMigMode_is __pyx_string_tab[123]
#define __pyx_kp_u_function_nvmlDeviceGetMinMaxCloc __pyx_string_tab[124]
#define __pyx_kp_u_function_nvmlDeviceGetMinMaxFanS __pyx_string_tab[125]
#define __pyx_kp_u_function_nvmlDeviceGetMinorNumbe __pyx_string_tab[126]
#define __pyx_kp_u_function_nvmlDeviceGetModuleId_i __pyx_string_tab[127]
#define __pyx_kp_u_function_nvmlDeviceGetMultiGpuBo __pyx_string_tab[128]
#define __pyx_kp_u_function_nvmlDeviceGetName_is_no __pyx_string_tab[129]
#define __pyx_kp_u_function_nvmlDeviceGetNumFans_is __pyx_string_tab[130]
#define __pyx_kp_u_function_nvmlDeviceGetNumGpuCore __pyx_string_tab[131]
#define __pyx_kp_u_function_nvmlDeviceGetNumaNodeId __pyx_string_tab[132]
#define __pyx_kp_u_function_nvmlDeviceGetNvLinkCapa __pyx_string_tab[133]
#define __pyx_kp_u_function_nvmlDeviceGetNvLinkErro __pyx_string_tab[134]
#define __pyx_kp_u_function_nvmlDeviceGetNvLinkInfo __pyx_string_tab[135]
#define __pyx_kp_u_function_nvmlDeviceGetNvLinkRemo __pyx_string_tab[136]
#define __pyx_kp_u_function_nvmlDeviceGetNvLinkRemo_2 __pyx_string_tab[137]
#define __pyx_kp_u_function_nvmlDeviceGetNvLinkStat __pyx_string_tab[138]
#define __pyx_kp_u_function_nvmlDeviceGetNvLinkVers __pyx_string_tab[139]
#define __pyx_kp_u_function_nvmlDeviceGetNvlinkBwMo __pyx_string_tab[140]
#define __pyx_kp_u_function_nvmlDeviceGetNvlinkSupp __pyx_string_tab[141]
#define __pyx_kp_u_function_nvmlDeviceGetOfaUtiliza __pyx_string_tab[142]
#define __pyx_kp_u_function_nvmlDeviceGetP2PStatus __pyx_string_tab[143]
#define __pyx_kp_u_function_nvmlDeviceGetPciInfoExt __pyx_string_tab[144]
#define __pyx_kp_u_function_nvmlDeviceGetPciInfo_v3 __pyx_string_tab[145]
#define __pyx_kp_u_function_nvmlDeviceGetPcieLinkMa __pyx_string_tab[146]
#define __pyx_kp_u_function_nvmlDeviceGetPcieReplay __pyx_string_tab[147]
#define __pyx_kp_u_function_nvmlDeviceGetPcieSpeed __pyx_string_tab[148]
#define __pyx_kp_u_function_nvmlDeviceGetPcieThroug __pyx_string_tab[149]
#define __pyx_kp_u_function_nvmlDeviceGetPdi_is_not __pyx_string_tab[150]
#define __pyx_kp_u_function_nvmlDeviceGetPerformanc __pyx_string_tab[151]
#define __pyx_kp_u_function_nvmlDeviceGetPerformanc_2 __pyx_string_tab[152]
#define __pyx_kp_u_function_nvmlDeviceGetPersistenc __pyx_string_tab[153]
#define __pyx_kp_u_function_nvmlDeviceGetPgpuMetada __pyx_string_tab[154]
#define __pyx_kp_u_function_nvmlDeviceGetPlatformIn __pyx_string_tab[155]
#define __pyx_kp_u_function_nvmlDeviceGetPowerManag __pyx_string_tab[156]
#define __pyx_kp_u_function_nvmlDeviceGetPowerManag_2 __pyx_string_tab[157]
#define __pyx_kp_u_function_nvmlDeviceGetPowerManag_3 __pyx_string_tab[158]
#define __pyx_kp_u_function_nvmlDeviceGetPowerMizer __pyx_string_tab[159]
#define __pyx_kp_u_function_nvmlDeviceGetPowerSourc __pyx_string_tab[160]
#define __pyx_kp_u_function_nvmlDeviceGetPowerState __pyx_string_tab[161]
#define __pyx_kp_u_function_nvmlDeviceGetPowerUsage __pyx_string_tab[162]
#define __pyx_kp_u_function_nvmlDeviceGetProcessUti __pyx_string_tab[163]
#define __pyx_kp_u_function_nvmlDeviceGetProcessesU __pyx_string_tab[164]
#define __pyx_kp_u_function_nvmlDeviceGetRemappedRo __pyx_string_tab[165]
#define __pyx_kp_u_function_nvmlDeviceGetRepairStat __pyx_string_tab[166]
#define __pyx_kp_u_function_nvmlDeviceGetRetiredPag __pyx_string_tab[167]
#define __pyx_kp_u_function_nvmlDeviceGetRetiredPag_2 __pyx_string_tab[168]
#define __pyx_kp_u_function_nvmlDeviceGetRetiredPag_3 __pyx_string_tab[169]
#define __pyx_kp_u_function_nvmlDeviceGetRowRemappe __pyx_string_tab[170]
#define __pyx_kp_u_function_nvmlDeviceGetRunningPro __pyx_string_tab[171]
#define __pyx_kp_u_function_nvmlDeviceGetSamples_is __pyx_string_tab[172]
#define __pyx_kp_u_function_nvmlDeviceGetSerial_is __pyx_string_tab[173]
#define __pyx_kp_u_function_nvmlDeviceGetSramEccErr __pyx_string_tab[174]
#define __pyx_kp_u_function_nvmlDeviceGetSramUnique __pyx_string_tab[175]
#define __pyx_kp_u_function_nvmlDeviceGetSupportedC __pyx_string_tab[176]
#define __pyx_kp_u_function_nvmlDeviceGetSupportedE __pyx_string_tab[177]
#define __pyx_kp_u_function_nvmlDeviceGetSupportedG __pyx_string_tab[178]
#define __pyx_kp_u_function_nvmlDeviceGetSupportedM __pyx_string_tab[179]
#define __pyx_kp_u_function_nvmlDeviceGetSupportedP __pyx_string_tab[180]
#define __pyx_kp_u_function_nvmlDeviceGetSupportedV __pyx_string_tab[181]
#define __pyx_kp_u_function_nvmlDeviceGetTargetFanS __pyx_string_tab[182]
#define __pyx_kp_u_function_nvmlDeviceGetTemperatur __pyx_string_tab[183]
#define __pyx_kp_u_function_nvmlDeviceGetTemperatur_2 __pyx_string_tab[184]
#define __pyx_kp_u_function_nvmlDeviceGetThermalSet __pyx_string_tab[185]
#define __pyx_kp_u_function_nvmlDeviceGetTopologyCo __pyx_string_tab[186]
#define __pyx_kp_u_function_nvmlDeviceGetTopologyNe __pyx_string_tab[187]
#define __pyx_kp_u_function_nvmlDeviceGetTotalEccEr __pyx_string_tab[188]
#define __pyx_kp_u_function_nvmlDeviceGetTotalEnerg __pyx_string_tab[189]
#define __pyx_kp_u_function_nvmlDeviceGetUUID_is_no __pyx_string_tab[190]
#define __pyx_kp_u_function_nvmlDeviceGetUtilizatio __pyx_string_tab[191]
#define __pyx_kp_u_function_nvmlDeviceGetVbiosVersi __pyx_string_tab[192]
#define __pyx_kp_u_function_nvmlDeviceGetVgpuCapabi __pyx_string_tab[193]
#define __pyx_kp_u_function_nvmlDeviceGetVgpuHetero __pyx_string_tab[194]
#define __pyx_kp_u_function_nvmlDeviceGetVgpuInstan __pyx_string_tab[195]
#define __pyx_kp_u_function_nvmlDeviceGetVgpuMetada __pyx_string_tab[196]
#define __pyx_kp_u_function_nvmlDeviceGetVgpuProces __pyx_string_tab[197]
#define __pyx_kp_u_function_nvmlDeviceGetVgpuProces_2 __pyx_string_tab[198]
#define __pyx_kp_u_function_nvmlDeviceGetVgpuSchedu __pyx_string_tab[199]
#define __pyx_kp_u_function_nvmlDeviceGetVgpuSchedu_2 __pyx_string_tab[200]
#define __pyx_kp_u_function_nvmlDeviceGetVgpuSchedu_3 __pyx_string_tab[201]
#define __pyx_kp_u_function_nvmlDeviceGetVgpuTypeCr __pyx_string_tab[202]
#define __pyx_kp_u_function_nvmlDeviceGetVgpuTypeSu __pyx_string_tab[203]
#define __pyx_kp_u_function_nvmlDeviceGetVgpuUtiliz __pyx_string_tab[204]
#define __pyx_kp_u_function_nvmlDeviceGetVirtualiza __pyx_string_tab[205]
#define __pyx_kp_u_function_nvmlDeviceIsMigDeviceHa __pyx_string_tab[206]
#define __pyx_kp_u_function_nvmlDeviceModifyDrainSt __pyx_string_tab[207]
#define __pyx_kp_u_function_nvmlDeviceOnSameBoard_i __pyx_string_tab[208]
#define __pyx_kp_u_function_nvmlDevicePowerSmoothin __pyx_string_tab[209]
#define __pyx_kp_u_function_nvmlDevicePowerSmoothin_2 __pyx_string_tab[210]
#define __pyx_kp_u_function_nvmlDevicePowerSmoothin_3 __pyx_string_tab[211]
#define __pyx_kp_u_function_nvmlDeviceQueryDrainSta __pyx_string_tab[212]
#define __pyx_kp_u_function_nvmlDeviceReadWritePRM __pyx_string_tab[213]
#define __pyx_kp_u_function_nvmlDeviceRegisterEvent __pyx_string_tab[214]
#define __pyx_kp_u_function_nvmlDeviceRemoveGpu_v2 __pyx_string_tab[215]
#define __pyx_kp_u_function_nvmlDeviceResetGpuLocke __pyx_string_tab[216]
#define __pyx_kp_u_function_nvmlDeviceResetMemoryLo __pyx_string_tab[217]
#define __pyx_kp_u_function_nvmlDeviceResetNvLinkEr __pyx_string_tab[218]
#define __pyx_kp_u_function_nvmlDeviceSetAPIRestric __pyx_string_tab[219]
#define __pyx_kp_u_function_nvmlDeviceSetAccounting __pyx_string_tab[220]
#define __pyx_kp_u_function_nvmlDeviceSetAutoBooste __pyx_string_tab[221]
#define __pyx_kp_u_function_nvmlDeviceSetClockOffse __pyx_string_tab[222]
#define __pyx_kp_u_function_nvmlDeviceSetComputeMod __pyx_string_tab[223]
#define __pyx_kp_u_function_nvmlDeviceSetConfComput __pyx_string_tab[224]
#define __pyx_kp_u_function_nvmlDeviceSetCpuAffinit __pyx_string_tab[225]
#define __pyx_kp_u_function_nvmlDeviceSetDefaultAut __pyx_string_tab[226]
#define __pyx_kp_u_function_nvmlDeviceSetDefaultFan __pyx_string_tab[227]
#define __pyx_kp_u_function_nvmlDeviceSetDramEncryp __pyx_string_tab[228]
#define __pyx_kp_u_function_nvmlDeviceSetDriverMode __pyx_string_tab[229]
#define __pyx_kp_u_function_nvmlDeviceSetEccMode_is __pyx_string_tab[230]
#define __pyx_kp_u_function_nvmlDeviceSetFanControl __pyx_string_tab[231]
#define __pyx_kp_u_function_nvmlDeviceSetFanSpeed_v __pyx_string_tab[232]
#define __pyx_kp_u_function_nvmlDeviceSetGpuLockedC __pyx_string_tab[233]
#define __pyx_kp_u_function_nvmlDeviceSetGpuOperati __pyx_string_tab[234]
#define __pyx_kp_u_function_nvmlDeviceSetHostname_v __pyx_string_tab[235]
#define __pyx_kp_u_function_nvmlDeviceSetMemoryLock __pyx_string_tab[236]
#define __pyx_kp_u_function_nvmlDeviceSetMigMode_is __pyx_string_tab[237]
#define __pyx_kp_u_function_nvmlDeviceSetNvLinkDevi __pyx_string_tab[238]
#define __pyx_kp_u_function_nvmlDeviceSetNvlinkBwMo __pyx_string_tab[239]
#define __pyx_kp_u_function_nvmlDeviceSetPersistenc __pyx_string_tab[240]
#define __pyx_kp_u_function_nvmlDeviceSetPowerManag __pyx_string_tab[241]
#define __pyx_kp_u_function_nvmlDeviceSetPowerManag_2 __pyx_string_tab[242]
#define __pyx_kp_u_function_nvmlDeviceSetPowerMizer __pyx_string_tab[243]
#define __pyx_kp_u_function_nvmlDeviceSetTemperatur __pyx_string_tab[244]
#define __pyx_kp_u_function_nvmlDeviceSetVgpuCapabi __pyx_string_tab[245]
#define __pyx_kp_u_function_nvmlDeviceSetVgpuHetero __pyx_string_tab[246]
#define __pyx_kp_u_function_nvmlDeviceSetVgpuSchedu __pyx_string_tab[247]
#define __pyx_kp_u_function_nvmlDeviceSetVirtualiza __pyx_string_tab[248]
#define __pyx_kp_u_function_nvmlDeviceValidateInfor __pyx_string_tab[249]
#define __pyx_kp_u_function_nvmlDeviceWorkloadPower __pyx_string_tab[250]
#define __pyx_kp_u_function_nvmlErrorString_is_not __pyx_string_tab[251]
#define __pyx_kp_u_function_nvmlEventSetCreate_is_n __pyx_string_tab[252]
#define __pyx_kp_u_function_nvmlEventSetFree_is_not __pyx_string_tab[253]
#define __pyx_kp_u_function_nvmlEventSetWait_v2_is __pyx_string_tab[254]
#define __pyx_kp_u_function_nvmlGetExcludedDeviceCo __pyx_string_tab[255]
#define __pyx_kp_u_function_nvmlGetExcludedDeviceIn __pyx_string_tab[256]
#define __pyx_kp_u_function_nvmlGetVgpuCompatibilit __pyx_string_tab[257]
#define __pyx_kp_u_function_nvmlGetVgpuDriverCapabi __pyx_string_tab[258]
#define __pyx_kp_u_function_nvmlGetVgpuVersion_is_n __pyx_string_tab[259]
#define __pyx_kp_u_function_nvmlGpmMigSampleGet_is __pyx_string_tab[260]
#define __pyx_kp_u_function_nvmlGpmQueryDeviceSuppo __pyx_string_tab[261]
#define __pyx_kp_u_function_nvmlGpmQueryIfStreaming __pyx_string_tab[262]
#define __pyx_kp_u_function_nvmlGpmSampleGet_is_not __pyx_string_tab[263]
#define __pyx_kp_u_function_nvmlGpmSetStreamingEnab __pyx_string_tab[264]
#define __pyx_kp_u_function_nvmlGpuInstanceCreateCo __pyx_string_tab[265]
#define __pyx_kp_u_function_nvmlGpuInstanceCreateCo_2 __pyx_string_tab[266]
#define __pyx_kp_u_function_nvmlGpuInstanceDestroy __pyx_string_tab[267]
#define __pyx_kp_u_function_nvmlGpuInstanceGetActiv __pyx_string_tab[268]
#define __pyx_kp_u_function_nvmlGpuInstanceGetCompu __pyx_string_tab[269]
#define __pyx_kp_u_function_nvmlGpuInstanceGetCompu_2 __pyx_string_tab[270]
#define __pyx_kp_u_function_nvmlGpuInstanceGetCompu_3 __pyx_string_tab[271]
#define __pyx_kp_u_function_nvmlGpuInstanceGetCompu_4 __pyx_string_tab[272]
#define __pyx_kp_u_function_nvmlGpuInstanceGetCompu_5 __pyx_string_tab[273]
#define __pyx_kp_u_function_nvmlGpuInstanceGetCreat __pyx_string_tab[274]
#define __pyx_kp_u_function_nvmlGpuInstanceGetInfo __pyx_string_tab[275]
#define __pyx_kp_u_function_nvmlGpuInstanceGetVgpuH __pyx_string_tab[276]
#define __pyx_kp_u_function_nvmlGpuInstanceGetVgpuS __pyx_string_tab[277]
#define __pyx_kp_u_function_nvmlGpuInstanceGetVgpuS_2 __pyx_string_tab[278]
#define __pyx_kp_u_function_nvmlGpuInstanceGetVgpuT __pyx_string_tab[279]
#define __pyx_kp_u_function_nvmlGpuInstanceSetVgpuH __pyx_string_tab[280]
#define __pyx_kp_u_function_nvmlGpuInstanceSetVgpuS __pyx_string_tab[281]
#define __pyx_kp_u_function_nvmlInitWithFlags_is_no __pyx_string_tab[282]
#define __pyx_kp_u_function_nvmlInit_v2_is_not_foun __pyx_string_tab[283]
#define __pyx_kp_u_function_nvmlSetVgpuVersion_is_n __pyx_string_tab[284]
#define __pyx_kp_u_function_nvmlShutdown_is_not_fou __pyx_string_tab[285]
#define __pyx_kp_u_function_nvmlSystemEventSetCreat __pyx_string_tab[286]
#define __pyx_kp_u_function_nvmlSystemEventSetFree __pyx_string_tab[287]
#define __pyx_kp_u_function_nvmlSystemEventSetWait __pyx_string_tab[288]
#define __pyx_kp_u_function_nvmlSystemGetConfComput __pyx_string_tab[289]
#define __pyx_kp_u_function_nvmlSystemGetConfComput_2 __pyx_string_tab[290]
#define __pyx_kp_u_function_nvmlSystemGetConfComput_3 __pyx_string_tab[291]
#define __pyx_kp_u_function_nvmlSystemGetConfComput_4 __pyx_string_tab[292]
#define __pyx_kp_u_function_nvmlSystemGetConfComput_5 __pyx_string_tab[293]
#define __pyx_kp_u_function_nvmlSystemGetCudaDriver __pyx_string_tab[294]
#define __pyx_kp_u_function_nvmlSystemGetCudaDriver_2 __pyx_string_tab[295]
#define __pyx_kp_u_function_nvmlSystemGetDriverBran __pyx_string_tab[296]
#define __pyx_kp_u_function_nvmlSystemGetDriverVers __pyx_string_tab[297]
#define __pyx_kp_u_function_nvmlSystemGetHicVersion __pyx_string_tab[298]
#define __pyx_kp_u_function_nvmlSystemGetNVMLVersio __pyx_string_tab[299]
#define __pyx_kp_u_function_nvmlSystemGetNvlinkBwMo __pyx_string_tab[300]
#define __pyx_kp_u_function_nvmlSystemGetProcessNam __pyx_string_tab[301]
#define __pyx_kp_u_function_nvmlSystemGetTopologyGp __pyx_string_tab[302]
#define __pyx_kp_u_function_nvmlSystemRegisterEvent __pyx_string_tab[303]
#define __pyx_kp_u_function_nvmlSystemSetConfComput __pyx_string_tab[304]
#define __pyx_kp_u_function_nvmlSystemSetConfComput_2 __pyx_string_tab[305]
#define __pyx_kp_u_function_nvmlSystemSetNvlinkBwMo __pyx_string_tab[306]
#define __pyx_kp_u_function_nvmlUnitGetCount_is_not __pyx_string_tab[307]
#define __pyx_kp_u_function_nvmlUnitGetDevices_is_n __pyx_string_tab[308]
#define __pyx_kp_u_function_nvmlUnitGetFanSpeedInfo __pyx_string_tab[309]
#define __pyx_kp_u_function_nvmlUnitGetHandleByInde __pyx_string_tab[310]
#define __pyx_kp_u_function_nvmlUnitGetLedState_is __pyx_string_tab[311]
#define __pyx_kp_u_function_nvmlUnitGetPsuInfo_is_n __pyx_string_tab[312]
#define __pyx_kp_u_function_nvmlUnitGetTemperature __pyx_string_tab[313]
#define __pyx_kp_u_function_nvmlUnitGetUnitInfo_is __pyx_string_tab[314]
#define __pyx_kp_u_function_nvmlUnitSetLedState_is __pyx_string_tab[315]
#define __pyx_kp_u_function_nvmlVgpuInstanceClearAc __pyx_string_tab[316]
#define __pyx_kp_u_function_nvmlVgpuInstanceGetAcco __pyx_string_tab[317]
#define __pyx_kp_u_function_nvmlVgpuInstanceGetAcco_2 __pyx_string_tab[318]
#define __pyx_kp_u_function_nvmlVgpuInstanceGetAcco_3 __pyx_string_tab[319]
#define __pyx_kp_u_function_nvmlVgpuInstanceGetEccM __pyx_string_tab[320]
#define __pyx_kp_u_function_nvmlVgpuInstanceGetEnco __pyx_string_tab[321]
#define __pyx_kp_u_function_nvmlVgpuInstanceGetEnco_2 __pyx_string_tab[322]
#define __pyx_kp_u_function_nvmlVgpuInstanceGetEnco_3 __pyx_string_tab[323]
#define __pyx_kp_u_function_nvmlVgpuInstanceGetFBCS __pyx_string_tab[324]
#define __pyx_kp_u_function_nvmlVgpuInstanceGetFBCS_2 __pyx_string_tab[325]
#define __pyx_kp_u_function_nvmlVgpuInstanceGetFbUs __pyx_string_tab[326]
#define __pyx_kp_u_function_nvmlVgpuInstanceGetFram __pyx_string_tab[327]
#define __pyx_kp_u_function_nvmlVgpuInstanceGetGpuI __pyx_string_tab[328]
#define __pyx_kp_u_function_nvmlVgpuInstanceGetGpuP __pyx_string_tab[329]
#define __pyx_kp_u_function_nvmlVgpuInstanceGetLice __pyx_string_tab[330]
#define __pyx_kp_u_function_nvmlVgpuInstanceGetLice_2 __pyx_string_tab[331]
#define __pyx_kp_u_function_nvmlVgpuInstanceGetMdev __pyx_string_tab[332]
#define __pyx_kp_u_function_nvmlVgpuInstanceGetMeta __pyx_string_tab[333]
#define __pyx_kp_u_function_nvmlVgpuInstanceGetPlac __pyx_string_tab[334]
#define __pyx_kp_u_function_nvmlVgpuInstanceGetRunt __pyx_string_tab[335]
#define __pyx_kp_u_function_nvmlVgpuInstanceGetType __pyx_string_tab[336]
#define __pyx_kp_u_function_nvmlVgpuInstanceGetUUID __pyx_string_tab[337]
#define __pyx_kp_u_function_nvmlVgpuInstanceGetVmDr __pyx_string_tab[338]
#define __pyx_kp_u_function_nvmlVgpuInstanceGetVmID __pyx_string_tab[339]
#define __pyx_kp_u_function_nvmlVgpuInstanceSetEnco __pyx_string_tab[340]
#define __pyx_kp_u_function_nvmlVgpuTypeGetBAR1Info __pyx_string_tab[341]
#define __pyx_kp_u_function_nvmlVgpuTypeGetCapabili __pyx_string_tab[342]
#define __pyx_kp_u_function_nvmlVgpuTypeGetClass_is __pyx_string_tab[343]
#define __pyx_kp_u_function_nvmlVgpuTypeGetDeviceID __pyx_string_tab[344]
#define __pyx_kp_u_function_nvmlVgpuTypeGetFbReserv __pyx_string_tab[345]
#define __pyx_kp_u_function_nvmlVgpuTypeGetFrameRat __pyx_string_tab[346]
#define __pyx_kp_u_function_nvmlVgpuTypeGetFramebuf __pyx_string_tab[347]
#define __pyx_kp_u_function_nvmlVgpuTypeGetGpuInsta __pyx_string_tab[348]
#define __pyx_kp_u_function_nvmlVgpuTypeGetGspHeapS __pyx_string_tab[349]
#define __pyx_kp_u_function_nvmlVgpuTypeGetLicense __pyx_string_tab[350]
#define __pyx_kp_u_function_nvmlVgpuTypeGetMaxInsta __pyx_string_tab[351]
#define __pyx_kp_u_function_nvmlVgpuTypeGetMaxInsta_2 __pyx_string_tab[352]
#define __pyx_kp_u_function_nvmlVgpuTypeGetMaxInsta_3 __pyx_string_tab[353]
#define __pyx_kp_u_function_nvmlVgpuTypeGetName_is __pyx_string_tab[354]
#define __pyx_kp_u_function_nvmlVgpuTypeGetNumDispl __pyx_string_tab[355]
#define __pyx_kp_u_function_nvmlVgpuTypeGetResoluti __pyx_string_tab[356]
#define __pyx_n_u_FunctionNotFoundError __pyx_string_tab[357]
#define __pyx_n_u_Lock __pyx_string_tab[358]
#define __pyx_n_u_NotSupportedError __pyx_string_tab[359]
#define __pyx_n_u_Pyx_PyDict_NextRef __pyx_string_tab[360]
#define __pyx_n_u_asyncio_coroutines __pyx_string_tab[361]
#define __pyx_n_u_cline_in_traceback __pyx_string_tab[362]
#define __pyx_n_u_cuda_bindings__internal__nvml __pyx_string_tab[363]
#define __pyx_n_u_cuda_pathfinder __pyx_string_tab[364]
#define __pyx_n_u_enter __pyx_string_tab[365]
#define __pyx_n_u_exit __pyx_string_tab[366]
#define __pyx_n_u_func __pyx_string_tab[367]
#define __pyx_n_u_inspect_function_pointer __pyx_string_tab[368]
#define __pyx_n_u_inspect_function_pointers __pyx_string_tab[369]
#define __pyx_n_u_is_coroutine __pyx_string_tab[370]
#define __pyx_n_u_items __pyx_string_tab[371]
#define __pyx_n_u_load_nvidia_dynamic_lib __pyx_string_tab[372]
#define __pyx_n_u_main __pyx_string_tab[373]
#define __pyx_n_u_module __pyx_string_tab[374]
#define __pyx_n_u_name __pyx_string_tab[375]
#define __pyx_n_u_name_2 __pyx_string_tab[376]
#define __pyx_n_u_nvmlComputeInstanceDestroy_2 __pyx_string_tab[377]
#define __pyx_n_u_nvmlComputeInstanceGetInfo_v2_2 __pyx_string_tab[378]
#define __pyx_n_u_nvmlDeviceClearAccountingPids_2 __pyx_string_tab[379]
#define __pyx_n_u_nvmlDeviceClearCpuAffinity_2 __pyx_string_tab[380]
#define __pyx_n_u_nvmlDeviceClearEccErrorCounts_2 __pyx_string_tab[381]
#define __pyx_n_u_nvmlDeviceClearFieldValues_2 __pyx_string_tab[382]
#define __pyx_n_u_nvmlDeviceCreateGpuInstanceWit __pyx_string_tab[383]
#define __pyx_n_u_nvmlDeviceCreateGpuInstance_2 __pyx_string_tab[384]
#define __pyx_n_u_nvmlDeviceDiscoverGpus_2 __pyx_string_tab[385]
#define __pyx_n_u_nvmlDeviceGetAPIRestriction_2 __pyx_string_tab[386]
#define __pyx_n_u_nvmlDeviceGetAccountingBufferS __pyx_string_tab[387]
#define __pyx_n_u_nvmlDeviceGetAccountingMode_2 __pyx_string_tab[388]
#define __pyx_n_u_nvmlDeviceGetAccountingPids_2 __pyx_string_tab[389]
#define __pyx_n_u_nvmlDeviceGetAccountingStats_2 __pyx_string_tab[390]
#define __pyx_n_u_nvmlDeviceGetActiveVgpus_2 __pyx_string_tab[391]
#define __pyx_n_u_nvmlDeviceGetAdaptiveClockInfo __pyx_string_tab[392]
#define __pyx_n_u_nvmlDeviceGetAddressingMode_2 __pyx_string_tab[393]
#define __pyx_n_u_nvmlDeviceGetArchitecture_2 __pyx_string_tab[394]
#define __pyx_n_u_nvmlDeviceGetAttributes_v2_2 __pyx_string_tab[395]
#define __pyx_n_u_nvmlDeviceGetAutoBoostedClocks __pyx_string_tab[396]
#define __pyx_n_u_nvmlDeviceGetBAR1MemoryInfo_2 __pyx_string_tab[397]
#define __pyx_n_u_nvmlDeviceGetBoardId_2 __pyx_string_tab[398]
#define __pyx_n_u_nvmlDeviceGetBoardPartNumber_2 __pyx_string_tab[399]
#define __pyx_n_u_nvmlDeviceGetBrand_2 __pyx_string_tab[400]
#define __pyx_n_u_nvmlDeviceGetBridgeChipInfo_2 __pyx_string_tab[401]
#define __pyx_n_u_nvmlDeviceGetBusType_2 __pyx_string_tab[402]
#define __pyx_n_u_nvmlDeviceGetC2cModeInfoV_2 __pyx_string_tab[403]
#define __pyx_n_u_nvmlDeviceGetCapabilities_2 __pyx_string_tab[404]
#define __pyx_n_u_nvmlDeviceGetClkMonStatus_2 __pyx_string_tab[405]
#define __pyx_n_u_nvmlDeviceGetClockInfo_2 __pyx_string_tab[406]
#define __pyx_n_u_nvmlDeviceGetClockOffsets_2 __pyx_string_tab[407]
#define __pyx_n_u_nvmlDeviceGetClock_2 __pyx_string_tab[408]
#define __pyx_n_u_nvmlDeviceGetComputeInstanceId_2 __pyx_string_tab[409]
#define __pyx_n_u_nvmlDeviceGetComputeMode_2 __pyx_string_tab[410]
#define __pyx_n_u_nvmlDeviceGetComputeRunningPro __pyx_string_tab[411]
#define __pyx_n_u_nvmlDeviceGetConfComputeGpuAtt __pyx_string_tab[412]
#define __pyx_n_u_nvmlDeviceGetConfComputeGpuCer __pyx_string_tab[413]
#define __pyx_n_u_nvmlDeviceGetConfComputeMemSiz __pyx_string_tab[414]
#define __pyx_n_u_nvmlDeviceGetConfComputeProtec __pyx_string_tab[415]
#define __pyx_n_u_nvmlDeviceGetCoolerInfo_2 __pyx_string_tab[416]
#define __pyx_n_u_nvmlDeviceGetCount_v2_2 __pyx_string_tab[417]
#define __pyx_n_u_nvmlDeviceGetCpuAffinityWithin __pyx_string_tab[418]
#define __pyx_n_u_nvmlDeviceGetCpuAffinity_2 __pyx_string_tab[419]
#define __pyx_n_u_nvmlDeviceGetCreatableVgpus_2 __pyx_string_tab[420]
#define __pyx_n_u_nvmlDeviceGetCudaComputeCapabi __pyx_string_tab[421]
#define __pyx_n_u_nvmlDeviceGetCurrPcieLinkGener __pyx_string_tab[422]
#define __pyx_n_u_nvmlDeviceGetCurrPcieLinkWidth_2 __pyx_string_tab[423]
#define __pyx_n_u_nvmlDeviceGetCurrentClockFreqs_2 __pyx_string_tab[424]
#define __pyx_n_u_nvmlDeviceGetCurrentClocksEven __pyx_string_tab[425]
#define __pyx_n_u_nvmlDeviceGetDecoderUtilizatio __pyx_string_tab[426]
#define __pyx_n_u_nvmlDeviceGetDefaultEccMode_2 __pyx_string_tab[427]
#define __pyx_n_u_nvmlDeviceGetDeviceHandleFromM __pyx_string_tab[428]
#define __pyx_n_u_nvmlDeviceGetDisplayActive_2 __pyx_string_tab[429]
#define __pyx_n_u_nvmlDeviceGetDisplayMode_2 __pyx_string_tab[430]
#define __pyx_n_u_nvmlDeviceGetDramEncryptionMod __pyx_string_tab[431]
#define __pyx_n_u_nvmlDeviceGetDriverModel_v2_2 __pyx_string_tab[432]
#define __pyx_n_u_nvmlDeviceGetDynamicPstatesInf __pyx_string_tab[433]
#define __pyx_n_u_nvmlDeviceGetEccMode_2 __pyx_string_tab[434]
#define __pyx_n_u_nvmlDeviceGetEncoderCapacity_2 __pyx_string_tab[435]
#define __pyx_n_u_nvmlDeviceGetEncoderSessions_2 __pyx_string_tab[436]
#define __pyx_n_u_nvmlDeviceGetEncoderStats_2 __pyx_string_tab[437]
#define __pyx_n_u_nvmlDeviceGetEncoderUtilizatio __pyx_string_tab[438]
#define __pyx_n_u_nvmlDeviceGetEnforcedPowerLimi __pyx_string_tab[439]
#define __pyx_n_u_nvmlDeviceGetFBCSessions_2 __pyx_string_tab[440]
#define __pyx_n_u_nvmlDeviceGetFBCStats_2 __pyx_string_tab[441]
#define __pyx_n_u_nvmlDeviceGetFanControlPolicy __pyx_string_tab[442]
#define __pyx_n_u_nvmlDeviceGetFanSpeedRPM_2 __pyx_string_tab[443]
#define __pyx_n_u_nvmlDeviceGetFanSpeed_2 __pyx_string_tab[444]
#define __pyx_n_u_nvmlDeviceGetFanSpeed_v2_2 __pyx_string_tab[445]
#define __pyx_n_u_nvmlDeviceGetFieldValues_2 __pyx_string_tab[446]
#define __pyx_n_u_nvmlDeviceGetGpcClkMinMaxVfOff __pyx_string_tab[447]
#define __pyx_n_u_nvmlDeviceGetGpcClkVfOffset_2 __pyx_string_tab[448]
#define __pyx_n_u_nvmlDeviceGetGpuFabricInfoV_2 __pyx_string_tab[449]
#define __pyx_n_u_nvmlDeviceGetGpuInstanceById_2 __pyx_string_tab[450]
#define __pyx_n_u_nvmlDeviceGetGpuInstanceId_2 __pyx_string_tab[451]
#define __pyx_n_u_nvmlDeviceGetGpuInstancePossib __pyx_string_tab[452]
#define __pyx_n_u_nvmlDeviceGetGpuInstanceProfil __pyx_string_tab[453]
#define __pyx_n_u_nvmlDeviceGetGpuInstanceProfil_2 __pyx_string_tab[454]
#define __pyx_n_u_nvmlDeviceGetGpuInstanceRemain __pyx_string_tab[455]
#define __pyx_n_u_nvmlDeviceGetGpuInstances_2 __pyx_string_tab[456]
#define __pyx_n_u_nvmlDeviceGetGpuMaxPcieLinkGen __pyx_string_tab[457]
#define __pyx_n_u_nvmlDeviceGetGpuOperationMode_2 __pyx_string_tab[458]
#define __pyx_n_u_nvmlDeviceGetGridLicensableFea __pyx_string_tab[459]
#define __pyx_n_u_nvmlDeviceGetGspFirmwareMode_2 __pyx_string_tab[460]
#define __pyx_n_u_nvmlDeviceGetGspFirmwareVersio __pyx_string_tab[461]
#define __pyx_n_u_nvmlDeviceGetHandleByIndex_v2_2 __pyx_string_tab[462]
#define __pyx_n_u_nvmlDeviceGetHandleByPciBusId __pyx_string_tab[463]
#define __pyx_n_u_nvmlDeviceGetHandleBySerial_2 __pyx_string_tab[464]
#define __pyx_n_u_nvmlDeviceGetHandleByUUIDV_2 __pyx_string_tab[465]
#define __pyx_n_u_nvmlDeviceGetHandleByUUID_2 __pyx_string_tab[466]
#define __pyx_n_u_nvmlDeviceGetHostVgpuMode_2 __pyx_string_tab[467]
#define __pyx_n_u_nvmlDeviceGetHostname_v1_2 __pyx_string_tab[468]
#define __pyx_n_u_nvmlDeviceGetIndex_2 __pyx_string_tab[469]
#define __pyx_n_u_nvmlDeviceGetInforomConfigurat __pyx_string_tab[470]
#define __pyx_n_u_nvmlDeviceGetInforomImageVersi __pyx_string_tab[471]
#define __pyx_n_u_nvmlDeviceGetInforomVersion_2 __pyx_string_tab[472]
#define __pyx_n_u_nvmlDeviceGetIrqNum_2 __pyx_string_tab[473]
#define __pyx_n_u_nvmlDeviceGetJpgUtilization_2 __pyx_string_tab[474]
#define __pyx_n_u_nvmlDeviceGetLastBBXFlushTime_2 __pyx_string_tab[475]
#define __pyx_n_u_nvmlDeviceGetMPSComputeRunning __pyx_string_tab[476]
#define __pyx_n_u_nvmlDeviceGetMarginTemperature_2 __pyx_string_tab[477]
#define __pyx_n_u_nvmlDeviceGetMaxClockInfo_2 __pyx_string_tab[478]
#define __pyx_n_u_nvmlDeviceGetMaxCustomerBoostC __pyx_string_tab[479]
#define __pyx_n_u_nvmlDeviceGetMaxMigDeviceCount_2 __pyx_string_tab[480]
#define __pyx_n_u_nvmlDeviceGetMaxPcieLinkGenera __pyx_string_tab[481]
#define __pyx_n_u_nvmlDeviceGetMaxPcieLinkWidth_2 __pyx_string_tab[482]
#define __pyx_n_u_nvmlDeviceGetMemClkMinMaxVfOff __pyx_string_tab[483]
#define __pyx_n_u_nvmlDeviceGetMemClkVfOffset_2 __pyx_string_tab[484]
#define __pyx_n_u_nvmlDeviceGetMemoryAffinity_2 __pyx_string_tab[485]
#define __pyx_n_u_nvmlDeviceGetMemoryBusWidth_2 __pyx_string_tab[486]
#define __pyx_n_u_nvmlDeviceGetMemoryErrorCounte __pyx_string_tab[487]
#define __pyx_n_u_nvmlDeviceGetMemoryInfo_v2_2 __pyx_string_tab[488]
#define __pyx_n_u_nvmlDeviceGetMigDeviceHandleBy __pyx_string_tab[489]
#define __pyx_n_u_nvmlDeviceGetMigMode_2 __pyx_string_tab[490]
#define __pyx_n_u_nvmlDeviceGetMinMaxClockOfPSta __pyx_string_tab[491]
#define __pyx_n_u_nvmlDeviceGetMinMaxFanSpeed_2 __pyx_string_tab[492]
#define __pyx_n_u_nvmlDeviceGetMinorNumber_2 __pyx_string_tab[493]
#define __pyx_n_u_nvmlDeviceGetModuleId_2 __pyx_string_tab[494]
#define __pyx_n_u_nvmlDeviceGetMultiGpuBoard_2 __pyx_string_tab[495]
#define __pyx_n_u_nvmlDeviceGetName_2 __pyx_string_tab[496]
#define __pyx_n_u_nvmlDeviceGetNumFans_2 __pyx_string_tab[497]
#define __pyx_n_u_nvmlDeviceGetNumGpuCores_2 __pyx_string_tab[498]
#define __pyx_n_u_nvmlDeviceGetNumaNodeId_2 __pyx_string_tab[499]
#define __pyx_n_u_nvmlDeviceGetNvLinkCapability_2 __pyx_string_tab[500]
#define __pyx_n_u_nvmlDeviceGetNvLinkErrorCounte __pyx_string_tab[501]
#define __pyx_n_u_nvmlDeviceGetNvLinkInfo_2 __pyx_string_tab[502]
#define __pyx_n_u_nvmlDeviceGetNvLinkRemoteDevic __pyx_string_tab[503]
#define __pyx_n_u_nvmlDeviceGetNvLinkRemotePciIn __pyx_string_tab[504]
#define __pyx_n_u_nvmlDeviceGetNvLinkState_2 __pyx_string_tab[505]
#define __pyx_n_u_nvmlDeviceGetNvLinkVersion_2 __pyx_string_tab[506]
#define __pyx_n_u_nvmlDeviceGetNvlinkBwMode_2 __pyx_string_tab[507]
#define __pyx_n_u_nvmlDeviceGetNvlinkSupportedBw __pyx_string_tab[508]
#define __pyx_n_u_nvmlDeviceGetOfaUtilization_2 __pyx_string_tab[509]
#define __pyx_n_u_nvmlDeviceGetP2PStatus_2 __pyx_string_tab[510]
#define __pyx_n_u_nvmlDeviceGetPciInfoExt_2 __pyx_string_tab[511]
#define __pyx_n_u_nvmlDeviceGetPciInfo_v3_2 __pyx_string_tab[512]
#define __pyx_n_u_nvmlDeviceGetPcieLinkMaxSpeed_2 __pyx_string_tab[513]
#define __pyx_n_u_nvmlDeviceGetPcieReplayCounter_2 __pyx_string_tab[514]
#define __pyx_n_u_nvmlDeviceGetPcieSpeed_2 __pyx_string_tab[515]
#define __pyx_n_u_nvmlDeviceGetPcieThroughput_2 __pyx_string_tab[516]
#define __pyx_n_u_nvmlDeviceGetPdi_2 __pyx_string_tab[517]
#define __pyx_n_u_nvmlDeviceGetPerformanceModes_2 __pyx_string_tab[518]
#define __pyx_n_u_nvmlDeviceGetPerformanceState_2 __pyx_string_tab[519]
#define __pyx_n_u_nvmlDeviceGetPersistenceMode_2 __pyx_string_tab[520]
#define __pyx_n_u_nvmlDeviceGetPgpuMetadataStrin __pyx_string_tab[521]
#define __pyx_n_u_nvmlDeviceGetPlatformInfo_2 __pyx_string_tab[522]
#define __pyx_n_u_nvmlDeviceGetPowerManagementDe __pyx_string_tab[523]
#define __pyx_n_u_nvmlDeviceGetPowerManagementLi __pyx_string_tab[524]
#define __pyx_n_u_nvmlDeviceGetPowerManagementLi_2 __pyx_string_tab[525]
#define __pyx_n_u_nvmlDeviceGetPowerMizerMode_v1_2 __pyx_string_tab[526]
#define __pyx_n_u_nvmlDeviceGetPowerSource_2 __pyx_string_tab[527]
#define __pyx_n_u_nvmlDeviceGetPowerState_2 __pyx_string_tab[528]
#define __pyx_n_u_nvmlDeviceGetPowerUsage_2 __pyx_string_tab[529]
#define __pyx_n_u_nvmlDeviceGetProcessUtilizatio __pyx_string_tab[530]
#define __pyx_n_u_nvmlDeviceGetProcessesUtilizat __pyx_string_tab[531]
#define __pyx_n_u_nvmlDeviceGetRemappedRows_2 __pyx_string_tab[532]
#define __pyx_n_u_nvmlDeviceGetRepairStatus_2 __pyx_string_tab[533]
#define __pyx_n_u_nvmlDeviceGetRetiredPagesPendi __pyx_string_tab[534]
#define __pyx_n_u_nvmlDeviceGetRetiredPages_2 __pyx_string_tab[535]
#define __pyx_n_u_nvmlDeviceGetRetiredPages_v2_2 __pyx_string_tab[536]
#define __pyx_n_u_nvmlDeviceGetRowRemapperHistog __pyx_string_tab[537]
#define __pyx_n_u_nvmlDeviceGetRunningProcessDet __pyx_string_tab[538]
#define __pyx_n_u_nvmlDeviceGetSamples_2 __pyx_string_tab[539]
#define __pyx_n_u_nvmlDeviceGetSerial_2 __pyx_string_tab[540]
#define __pyx_n_u_nvmlDeviceGetSramEccErrorStatu __pyx_string_tab[541]
#define __pyx_n_u_nvmlDeviceGetSramUniqueUncorre __pyx_string_tab[542]
#define __pyx_n_u_nvmlDeviceGetSupportedClocksEv __pyx_string_tab[543]
#define __pyx_n_u_nvmlDeviceGetSupportedEventTyp __pyx_string_tab[544]
#define __pyx_n_u_nvmlDeviceGetSupportedGraphics __pyx_string_tab[545]
#define __pyx_n_u_nvmlDeviceGetSupportedMemoryCl __pyx_string_tab[546]
#define __pyx_n_u_nvmlDeviceGetSupportedPerforma __pyx_string_tab[547]
#define __pyx_n_u_nvmlDeviceGetSupportedVgpus_2 __pyx_string_tab[548]
#define __pyx_n_u_nvmlDeviceGetTargetFanSpeed_2 __pyx_string_tab[549]
#define __pyx_n_u_nvmlDeviceGetTemperatureThresh __pyx_string_tab[550]
#define __pyx_n_u_nvmlDeviceGetTemperatureV_2 __pyx_string_tab[551]
#define __pyx_n_u_nvmlDeviceGetThermalSettings_2 __pyx_string_tab[552]
#define __pyx_n_u_nvmlDeviceGetTopologyCommonAnc __pyx_string_tab[553]
#define __pyx_n_u_nvmlDeviceGetTopologyNearestGp __pyx_string_tab[554]
#define __pyx_n_u_nvmlDeviceGetTotalEccErrors_2 __pyx_string_tab[555]
#define __pyx_n_u_nvmlDeviceGetTotalEnergyConsum __pyx_string_tab[556]
#define __pyx_n_u_nvmlDeviceGetUUID_2 __pyx_string_tab[557]
#define __pyx_n_u_nvmlDeviceGetUtilizationRates_2 __pyx_string_tab[558]
#define __pyx_n_u_nvmlDeviceGetVbiosVersion_2 __pyx_string_tab[559]
#define __pyx_n_u_nvmlDeviceGetVgpuCapabilities_2 __pyx_string_tab[560]
#define __pyx_n_u_nvmlDeviceGetVgpuHeterogeneous __pyx_string_tab[561]
#define __pyx_n_u_nvmlDeviceGetVgpuInstancesUtil __pyx_string_tab[562]
#define __pyx_n_u_nvmlDeviceGetVgpuMetadata_2 __pyx_string_tab[563]
#define __pyx_n_u_nvmlDeviceGetVgpuProcessUtiliz __pyx_string_tab[564]
#define __pyx_n_u_nvmlDeviceGetVgpuProcessesUtil __pyx_string_tab[565]
#define __pyx_n_u_nvmlDeviceGetVgpuSchedulerCapa __pyx_string_tab[566]
#define __pyx_n_u_nvmlDeviceGetVgpuSchedulerLog_2 __pyx_string_tab[567]
#define __pyx_n_u_nvmlDeviceGetVgpuSchedulerStat __pyx_string_tab[568]
#define __pyx_n_u_nvmlDeviceGetVgpuTypeCreatable __pyx_string_tab[569]
#define __pyx_n_u_nvmlDeviceGetVgpuTypeSupported __pyx_string_tab[570]
#define __pyx_n_u_nvmlDeviceGetVgpuUtilization_2 __pyx_string_tab[571]
#define __pyx_n_u_nvmlDeviceGetVirtualizationMod __pyx_string_tab[572]
#define __pyx_n_u_nvmlDeviceIsMigDeviceHandle_2 __pyx_string_tab[573]
#define __pyx_n_u_nvmlDeviceModifyDrainState_2 __pyx_string_tab[574]
#define __pyx_n_u_nvmlDeviceOnSameBoard_2 __pyx_string_tab[575]
#define __pyx_n_u_nvmlDevicePowerSmoothingActiva __pyx_string_tab[576]
#define __pyx_n_u_nvmlDevicePowerSmoothingSetSta __pyx_string_tab[577]
#define __pyx_n_u_nvmlDevicePowerSmoothingUpdate __pyx_string_tab[578]
#define __pyx_n_u_nvmlDeviceQueryDrainState_2 __pyx_string_tab[579]
#define __pyx_n_u_nvmlDeviceReadWritePRM_v1_2 __pyx_string_tab[580]
#define __pyx_n_u_nvmlDeviceRegisterEvents_2 __pyx_string_tab[581]
#define __pyx_n_u_nvmlDeviceRemoveGpu_v2_2 __pyx_string_tab[582]
#define __pyx_n_u_nvmlDeviceResetGpuLockedClocks_2 __pyx_string_tab[583]
#define __pyx_n_u_nvmlDeviceResetMemoryLockedClo __pyx_string_tab[584]
#define __pyx_n_u_nvmlDeviceResetNvLinkErrorCoun __pyx_string_tab[585]
#define __pyx_n_u_nvmlDeviceSetAPIRestriction_2 __pyx_string_tab[586]
#define __pyx_n_u_nvmlDeviceSetAccountingMode_2 __pyx_string_tab[587]
#define __pyx_n_u_nvmlDeviceSetAutoBoostedClocks __pyx_string_tab[588]
#define __pyx_n_u_nvmlDeviceSetClockOffsets_2 __pyx_string_tab[589]
#define __pyx_n_u_nvmlDeviceSetComputeMode_2 __pyx_string_tab[590]
#define __pyx_n_u_nvmlDeviceSetConfComputeUnprot __pyx_string_tab[591]
#define __pyx_n_u_nvmlDeviceSetCpuAffinity_2 __pyx_string_tab[592]
#define __pyx_n_u_nvmlDeviceSetDefaultAutoBooste __pyx_string_tab[593]
#define __pyx_n_u_nvmlDeviceSetDefaultFanSpeed_v __pyx_string_tab[594]
#define __pyx_n_u_nvmlDeviceSetDramEncryptionMod __pyx_string_tab[595]
#define __pyx_n_u_nvmlDeviceSetDriverModel_2 __pyx_string_tab[596]
#define __pyx_n_u_nvmlDeviceSetEccMode_2 __pyx_string_tab[597]
#define __pyx_n_u_nvmlDeviceSetFanControlPolicy_2 __pyx_string_tab[598]
#define __pyx_n_u_nvmlDeviceSetFanSpeed_v2_2 __pyx_string_tab[599]
#define __pyx_n_u_nvmlDeviceSetGpuLockedClocks_2 __pyx_string_tab[600]
#define __pyx_n_u_nvmlDeviceSetGpuOperationMode_2 __pyx_string_tab[601]
#define __pyx_n_u_nvmlDeviceSetHostname_v1_2 __pyx_string_tab[602]
#define __pyx_n_u_nvmlDeviceSetMemoryLockedClock __pyx_string_tab[603]
#define __pyx_n_u_nvmlDeviceSetMigMode_2 __pyx_string_tab[604]
#define __pyx_n_u_nvmlDeviceSetNvLinkDeviceLowPo __pyx_string_tab[605]
#define __pyx_n_u_nvmlDeviceSetNvlinkBwMode_2 __pyx_string_tab[606]
#define __pyx_n_u_nvmlDeviceSetPersistenceMode_2 __pyx_string_tab[607]
#define __pyx_n_u_nvmlDeviceSetPowerManagementLi __pyx_string_tab[608]
#define __pyx_n_u_nvmlDeviceSetPowerManagementLi_2 __pyx_string_tab[609]
#define __pyx_n_u_nvmlDeviceSetPowerMizerMode_v1_2 __pyx_string_tab[610]
#define __pyx_n_u_nvmlDeviceSetTemperatureThresh __pyx_string_tab[611]
#define __pyx_n_u_nvmlDeviceSetVgpuCapabilities_2 __pyx_string_tab[612]
#define __pyx_n_u_nvmlDeviceSetVgpuHeterogeneous __pyx_string_tab[613]
#define __pyx_n_u_nvmlDeviceSetVgpuSchedulerStat __pyx_string_tab[614]
#define __pyx_n_u_nvmlDeviceSetVirtualizationMod __pyx_string_tab[615]
#define __pyx_n_u_nvmlDeviceValidateInforom_2 __pyx_string_tab[616]
#define __pyx_n_u_nvmlDeviceWorkloadPowerProfile __pyx_string_tab[617]
#define __pyx_n_u_nvmlErrorString_2 __pyx_string_tab[618]
#define __pyx_n_u_nvmlEventSetCreate_2 __pyx_string_tab[619]
#define __pyx_n_u_nvmlEventSetFree_2 __pyx_string_tab[620]
#define __pyx_n_u_nvmlEventSetWait_v2_2 __pyx_string_tab[621]
#define __pyx_n_u_nvmlGetExcludedDeviceCount_2 __pyx_string_tab[622]
#define __pyx_n_u_nvmlGetExcludedDeviceInfoByInd __pyx_string_tab[623]
#define __pyx_n_u_nvmlGetVgpuCompatibility_2 __pyx_string_tab[624]
#define __pyx_n_u_nvmlGetVgpuDriverCapabilities_2 __pyx_string_tab[625]
#define __pyx_n_u_nvmlGetVgpuVersion_2 __pyx_string_tab[626]
#define __pyx_n_u_nvmlGpmMigSampleGet_2 __pyx_string_tab[627]
#define __pyx_n_u_nvmlGpmQueryDeviceSupport_2 __pyx_string_tab[628]
#define __pyx_n_u_nvmlGpmQueryIfStreamingEnabled_2 __pyx_string_tab[629]
#define __pyx_n_u_nvmlGpmSampleGet_2 __pyx_string_tab[630]
#define __pyx_n_u_nvmlGpmSetStreamingEnabled_2 __pyx_string_tab[631]
#define __pyx_n_u_nvmlGpuInstanceCreateComputeIn __pyx_string_tab[632]
#define __pyx_n_u_nvmlGpuInstanceCreateComputeIn_2 __pyx_string_tab[633]
#define __pyx_n_u_nvmlGpuInstanceDestroy_2 __pyx_string_tab[634]
#define __pyx_n_u_nvmlGpuInstanceGetActiveVgpus_2 __pyx_string_tab[635]
#define __pyx_n_u_nvmlGpuInstanceGetComputeInsta __pyx_string_tab[636]
#define __pyx_n_u_nvmlGpuInstanceGetComputeInsta_2 __pyx_string_tab[637]
#define __pyx_n_u_nvmlGpuInstanceGetComputeInsta_3 __pyx_string_tab[638]
#define __pyx_n_u_nvmlGpuInstanceGetComputeInsta_4 __pyx_string_tab[639]
#define __pyx_n_u_nvmlGpuInstanceGetComputeInsta_5 __pyx_string_tab[640]
#define __pyx_n_u_nvmlGpuInstanceGetCreatableVgp __pyx_string_tab[641]
#define __pyx_n_u_nvmlGpuInstanceGetInfo_2 __pyx_string_tab[642]
#define __pyx_n_u_nvmlGpuInstanceGetVgpuHeteroge __pyx_string_tab[643]
#define __pyx_n_u_nvmlGpuInstanceGetVgpuSchedule __pyx_string_tab[644]
#define __pyx_n_u_nvmlGpuInstanceGetVgpuSchedule_2 __pyx_string_tab[645]
#define __pyx_n_u_nvmlGpuInstanceGetVgpuTypeCrea __pyx_string_tab[646]
#define __pyx_n_u_nvmlGpuInstanceSetVgpuHeteroge __pyx_string_tab[647]
#define __pyx_n_u_nvmlGpuInstanceSetVgpuSchedule __pyx_string_tab[648]
#define __pyx_n_u_nvmlInitWithFlags_2 __pyx_string_tab[649]
#define __pyx_n_u_nvmlInit_v2_2 __pyx_string_tab[650]
#define __pyx_n_u_nvmlSetVgpuVersion_2 __pyx_string_tab[651]
#define __pyx_n_u_nvmlShutdown_2 __pyx_string_tab[652]
#define __pyx_n_u_nvmlSystemEventSetCreate_2 __pyx_string_tab[653]
#define __pyx_n_u_nvmlSystemEventSetFree_2 __pyx_string_tab[654]
#define __pyx_n_u_nvmlSystemEventSetWait_2 __pyx_string_tab[655]
#define __pyx_n_u_nvmlSystemGetConfComputeCapabi __pyx_string_tab[656]
#define __pyx_n_u_nvmlSystemGetConfComputeGpusRe __pyx_string_tab[657]
#define __pyx_n_u_nvmlSystemGetConfComputeKeyRot __pyx_string_tab[658]
#define __pyx_n_u_nvmlSystemGetConfComputeSettin __pyx_string_tab[659]
#define __pyx_n_u_nvmlSystemGetConfComputeState_2 __pyx_string_tab[660]
#define __pyx_n_u_nvmlSystemGetCudaDriverVersion_2 __pyx_string_tab[661]
#define __pyx_n_u_nvmlSystemGetCudaDriverVersion_3 __pyx_string_tab[662]
#define __pyx_n_u_nvmlSystemGetDriverBranch_2 __pyx_string_tab[663]
#define __pyx_n_u_nvmlSystemGetDriverVersion_2 __pyx_string_tab[664]
#define __pyx_n_u_nvmlSystemGetHicVersion_2 __pyx_string_tab[665]
#define __pyx_n_u_nvmlSystemGetNVMLVersion_2 __pyx_string_tab[666]
#define __pyx_n_u_nvmlSystemGetNvlinkBwMode_2 __pyx_string_tab[667]
#define __pyx_n_u_nvmlSystemGetProcessName_2 __pyx_string_tab[668]
#define __pyx_n_u_nvmlSystemGetTopologyGpuSet_2 __pyx_string_tab[669]
#define __pyx_n_u_nvmlSystemRegisterEvents_2 __pyx_string_tab[670]
#define __pyx_n_u_nvmlSystemSetConfComputeGpusRe __pyx_string_tab[671]
#define __pyx_n_u_nvmlSystemSetConfComputeKeyRot __pyx_string_tab[672]
#define __pyx_n_u_nvmlSystemSetNvlinkBwMode_2 __pyx_string_tab[673]
#define __pyx_n_u_nvmlUnitGetCount_2 __pyx_string_tab[674]
#define __pyx_n_u_nvmlUnitGetDevices_2 __pyx_string_tab[675]
#define __pyx_n_u_nvmlUnitGetFanSpeedInfo_2 __pyx_string_tab[676]
#define __pyx_n_u_nvmlUnitGetHandleByIndex_2 __pyx_string_tab[677]
#define __pyx_n_u_nvmlUnitGetLedState_2 __pyx_string_tab[678]
#define __pyx_n_u_nvmlUnitGetPsuInfo_2 __pyx_string_tab[679]
#define __pyx_n_u_nvmlUnitGetTemperature_2 __pyx_string_tab[680]
#define __pyx_n_u_nvmlUnitGetUnitInfo_2 __pyx_string_tab[681]
#define __pyx_n_u_nvmlUnitSetLedState_2 __pyx_string_tab[682]
#define __pyx_n_u_nvmlVgpuInstanceClearAccountin __pyx_string_tab[683]
#define __pyx_n_u_nvmlVgpuInstanceGetAccountingM __pyx_string_tab[684]
#define __pyx_n_u_nvmlVgpuInstanceGetAccountingP __pyx_string_tab[685]
#define __pyx_n_u_nvmlVgpuInstanceGetAccountingS __pyx_string_tab[686]
#define __pyx_n_u_nvmlVgpuInstanceGetEccMode_2 __pyx_string_tab[687]
#define __pyx_n_u_nvmlVgpuInstanceGetEncoderCapa __pyx_string_tab[688]
#define __pyx_n_u_nvmlVgpuInstanceGetEncoderSess __pyx_string_tab[689]
#define __pyx_n_u_nvmlVgpuInstanceGetEncoderStat __pyx_string_tab[690]
#define __pyx_n_u_nvmlVgpuInstanceGetFBCSessions_2 __pyx_string_tab[691]
#define __pyx_n_u_nvmlVgpuInstanceGetFBCStats_2 __pyx_string_tab[692]
#define __pyx_n_u_nvmlVgpuInstanceGetFbUsage_2 __pyx_string_tab[693]
#define __pyx_n_u_nvmlVgpuInstanceGetFrameRateLi __pyx_string_tab[694]
#define __pyx_n_u_nvmlVgpuInstanceGetGpuInstance __pyx_string_tab[695]
#define __pyx_n_u_nvmlVgpuInstanceGetGpuPciId_2 __pyx_string_tab[696]
#define __pyx_n_u_nvmlVgpuInstanceGetLicenseInfo __pyx_string_tab[697]
#define __pyx_n_u_nvmlVgpuInstanceGetLicenseStat __pyx_string_tab[698]
#define __pyx_n_u_nvmlVgpuInstanceGetMdevUUID_2 __pyx_string_tab[699]
#define __pyx_n_u_nvmlVgpuInstanceGetMetadata_2 __pyx_string_tab[700]
#define __pyx_n_u_nvmlVgpuInstanceGetPlacementId_2 __pyx_string_tab[701]
#define __pyx_n_u_nvmlVgpuInstanceGetRuntimeStat __pyx_string_tab[702]
#define __pyx_n_u_nvmlVgpuInstanceGetType_2 __pyx_string_tab[703]
#define __pyx_n_u_nvmlVgpuInstanceGetUUID_2 __pyx_string_tab[704]
#define __pyx_n_u_nvmlVgpuInstanceGetVmDriverVer __pyx_string_tab[705]
#define __pyx_n_u_nvmlVgpuInstanceGetVmID_2 __pyx_string_tab[706]
#define __pyx_n_u_nvmlVgpuInstanceSetEncoderCapa __pyx_string_tab[707]
#define __pyx_n_u_nvmlVgpuTypeGetBAR1Info_2 __pyx_string_tab[708]
#define __pyx_n_u_nvmlVgpuTypeGetCapabilities_2 __pyx_string_tab[709]
#define __pyx_n_u_nvmlVgpuTypeGetClass_2 __pyx_string_tab[710]
#define __pyx_n_u_nvmlVgpuTypeGetDeviceID_2 __pyx_string_tab[711]
#define __pyx_n_u_nvmlVgpuTypeGetFbReservation_2 __pyx_string_tab[712]
#define __pyx_n_u_nvmlVgpuTypeGetFrameRateLimit_2 __pyx_string_tab[713]
#define __pyx_n_u_nvmlVgpuTypeGetFramebufferSize_2 __pyx_string_tab[714]
#define __pyx_n_u_nvmlVgpuTypeGetGpuInstanceProf __pyx_string_tab[715]
#define __pyx_n_u_nvmlVgpuTypeGetGspHeapSize_2 __pyx_string_tab[716]
#define __pyx_n_u_nvmlVgpuTypeGetLicense_2 __pyx_string_tab[717]
#define __pyx_n_u_nvmlVgpuTypeGetMaxInstancesPer __pyx_string_tab[718]
#define __pyx_n_u_nvmlVgpuTypeGetMaxInstancesPer_2 __pyx_string_tab[719]
#define __pyx_n_u_nvmlVgpuTypeGetMaxInstances_2 __pyx_string_tab[720]
#define __pyx_n_u_nvmlVgpuTypeGetName_2 __pyx_string_tab[721]
#define __pyx_n_u_nvmlVgpuTypeGetNumDisplayHeads_2 __pyx_string_tab[722]
#define __pyx_n_u_nvmlVgpuTypeGetResolution_2 __pyx_string_tab[723]
#define __pyx_n_u_pop __pyx_string_tab[724]
#define __pyx_n_u_pyx_capi __pyx_string_tab[725]
#define __pyx_n_u_qualname __pyx_string_tab[726]
#define __pyx_n_u_set_name __pyx_string_tab[727]
#define __pyx_n_u_setdefault __pyx_string_tab[728]
#define __pyx_n_u_test __pyx_string_tab[729]
#define __pyx_n_u_threading __pyx_string_tab[730]
#define __pyx_n_u_utils __pyx_string_tab[731]
#define __pyx_n_u_values __pyx_string_tab[732]
#define __pyx_kp_b_char_const_nvmlReturn_t_nvmlRetu __pyx_string_tab[733]
#define __pyx_kp_b_iso88591_z_A_a_9AQ __pyx_string_tab[734]
#define __pyx_kp_b_iso88591_z_q_q_Q_Ja_A_Zq_Q_1_z_2_A_1_Ja __pyx_string_tab[735]
/* #### Code section: module_state_clear ### */
#if CYTHON_USE_MODULE_STATE
static CYTHON_SMALL_CODE int __pyx_m_clear(PyObject *m) {
  __pyx_mstatetype *clear_module_state = __Pyx_PyModule_GetState(m);
  if (!clear_module_state) return 0;
  Py_CLEAR(clear_module_state->__pyx_d);
  Py_CLEAR(clear_module_state->__pyx_b);
  Py_CLEAR(clear_module_state->__pyx_cython_runtime);
  Py_CLEAR(clear_module_state->__pyx_empty_tuple);
  Py_CLEAR(clear_module_state->__pyx_empty_bytes);
  Py_CLEAR(clear_module_state->__pyx_empty_unicode);
  #if CYTHON_PEP489_MULTI_PHASE_INIT
  __Pyx_State_RemoveModule(NULL);
  #endif
  for (int i=0; i<1; ++i) { Py_CLEAR(clear_module_state->__pyx_tuple[i]); }
  for (int i=0; i<2; ++i) { Py_CLEAR(clear_module_state->__pyx_codeobj_tab[i]); }
  for (int i=0; i<736; ++i) { Py_CLEAR(clear_module_state->__pyx_string_tab[i]); }
/* #### Code section: module_state_clear_contents ### */
/* CommonTypesMetaclass.module_state_clear */
Py_CLEAR(clear_module_state->__pyx_CommonTypesMetaclassType);

/* CythonFunctionShared.module_state_clear */
Py_CLEAR(clear_module_state->__pyx_CyFunctionType);

/* #### Code section: module_state_clear_end ### */
return 0;
}
#endif
/* #### Code section: module_state_traverse ### */
#if CYTHON_USE_MODULE_STATE
static CYTHON_SMALL_CODE int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
  __pyx_mstatetype *traverse_module_state = __Pyx_PyModule_GetState(m);
  if (!traverse_module_state) return 0;
  Py_VISIT(traverse_module_state->__pyx_d);
  Py_VISIT(traverse_module_state->__pyx_b);
  Py_VISIT(traverse_module_state->__pyx_cython_runtime);
  __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_tuple);
  __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_bytes);
  __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_unicode);
  for (int i=0; i<1; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_tuple[i]); }
  for (int i=0; i<2; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_codeobj_tab[i]); }
  for (int i=0; i<736; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_string_tab[i]); }
/* #### Code section: module_state_traverse_contents ### */
/* CommonTypesMetaclass.module_state_traverse */
Py_VISIT(traverse_module_state->__pyx_CommonTypesMetaclassType);

/* CythonFunctionShared.module_state_traverse */
Py_VISIT(traverse_module_state->__pyx_CyFunctionType);

/* #### Code section: module_state_traverse_end ### */
return 0;
}
#endif
/* #### Code section: module_code ### */

/* "cuda/bindings/_internal/_nvml.pyx":36
 *     const void* RTLD_DEFAULT 'RTLD_DEFAULT'
 * 
 * cdef int get_cuda_version():             # <<<<<<<<<<<<<<
 *     cdef void* handle = NULL
 *     cdef int err, driver_ver = 0
*/

static int __pyx_f_4cuda_8bindings_9_internal_5_nvml_get_cuda_version(void) {
  void *__pyx_v_handle;
  int __pyx_v_err;
  int __pyx_v_driver_ver;
  char *__pyx_v_err_msg;
  void *__pyx_v_cuDriverGetVersion;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  Py_ssize_t __pyx_t_5;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7[3];
  PyObject *__pyx_t_8 = NULL;
  size_t __pyx_t_9;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("get_cuda_version", 0);

  /* "cuda/bindings/_internal/_nvml.pyx":37
 * 
 * cdef int get_cuda_version():
 *     cdef void* handle = NULL             # <<<<<<<<<<<<<<
 *     cdef int err, driver_ver = 0
 * 
*/
  __pyx_v_handle = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":38
 * cdef int get_cuda_version():
 *     cdef void* handle = NULL
 *     cdef int err, driver_ver = 0             # <<<<<<<<<<<<<<
 * 
 *     # Load driver to check version
*/
  __pyx_v_driver_ver = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":41
 * 
 *     # Load driver to check version
 *     handle = dlopen('libcuda.so.1', RTLD_NOW | RTLD_GLOBAL)             # <<<<<<<<<<<<<<
 *     if handle == NULL:
 *         err_msg = dlerror()
*/
  __pyx_v_handle = dlopen(__pyx_k_libcuda_so_1, (RTLD_NOW | RTLD_GLOBAL));

  /* "cuda/bindings/_internal/_nvml.pyx":42
 *     # Load driver to check version
 *     handle = dlopen('libcuda.so.1', RTLD_NOW | RTLD_GLOBAL)
 *     if handle == NULL:             # <<<<<<<<<<<<<<
 *         err_msg = dlerror()
 *         raise NotSupportedError(f'CUDA driver is not found ({err_msg.decode()})')
*/
  __pyx_t_1 = (__pyx_v_handle == NULL);
  if (unlikely(__pyx_t_1)) {

    /* "cuda/bindings/_internal/_nvml.pyx":43
 *     handle = dlopen('libcuda.so.1', RTLD_NOW | RTLD_GLOBAL)
 *     if handle == NULL:
 *         err_msg = dlerror()             # <<<<<<<<<<<<<<
 *         raise NotSupportedError(f'CUDA driver is not found ({err_msg.decode()})')
 *     cuDriverGetVersion = dlsym(handle, "cuDriverGetVersion")
*/
    __pyx_v_err_msg = dlerror();

    /* "cuda/bindings/_internal/_nvml.pyx":44
 *     if handle == NULL:
 *         err_msg = dlerror()
 *         raise NotSupportedError(f'CUDA driver is not found ({err_msg.decode()})')             # <<<<<<<<<<<<<<
 *     cuDriverGetVersion = dlsym(handle, "cuDriverGetVersion")
 *     if cuDriverGetVersion == NULL:
*/
    __pyx_t_3 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_NotSupportedError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 44, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = __Pyx_ssize_strlen(__pyx_v_err_msg); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 44, __pyx_L1_error)
    __pyx_t_6 = __Pyx_decode_c_string(__pyx_v_err_msg, 0, __pyx_t_5, NULL, NULL, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 44, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7[0] = __pyx_mstate_global->__pyx_kp_u_CUDA_driver_is_not_found;
    __pyx_t_7[1] = __pyx_t_6;
    __pyx_t_7[2] = __pyx_mstate_global->__pyx_kp_u_;
    __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, 26 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6));
    if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 44, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_9 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_9 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_8};
      __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 44, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __PYX_ERR(0, 44, __pyx_L1_error)

    /* "cuda/bindings/_internal/_nvml.pyx":42
 *     # Load driver to check version
 *     handle = dlopen('libcuda.so.1', RTLD_NOW | RTLD_GLOBAL)
 *     if handle == NULL:             # <<<<<<<<<<<<<<
 *         err_msg = dlerror()
 *         raise NotSupportedError(f'CUDA driver is not found ({err_msg.decode()})')
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":45
 *         err_msg = dlerror()
 *         raise NotSupportedError(f'CUDA driver is not found ({err_msg.decode()})')
 *     cuDriverGetVersion = dlsym(handle, "cuDriverGetVersion")             # <<<<<<<<<<<<<<
 *     if cuDriverGetVersion == NULL:
 *         raise RuntimeError('Did not find cuDriverGetVersion symbol in libcuda.so.1')
*/
  __pyx_v_cuDriverGetVersion = dlsym(__pyx_v_handle, __pyx_k_cuDriverGetVersion);

  /* "cuda/bindings/_internal/_nvml.pyx":46
 *         raise NotSupportedError(f'CUDA driver is not found ({err_msg.decode()})')
 *     cuDriverGetVersion = dlsym(handle, "cuDriverGetVersion")
 *     if cuDriverGetVersion == NULL:             # <<<<<<<<<<<<<<
 *         raise RuntimeError('Did not find cuDriverGetVersion symbol in libcuda.so.1')
 *     err = (<int (*)(int*) noexcept nogil>cuDriverGetVersion)(&driver_ver)
*/
  __pyx_t_1 = (__pyx_v_cuDriverGetVersion == NULL);
  if (unlikely(__pyx_t_1)) {

    /* "cuda/bindings/_internal/_nvml.pyx":47
 *     cuDriverGetVersion = dlsym(handle, "cuDriverGetVersion")
 *     if cuDriverGetVersion == NULL:
 *         raise RuntimeError('Did not find cuDriverGetVersion symbol in libcuda.so.1')             # <<<<<<<<<<<<<<
 *     err = (<int (*)(int*) noexcept nogil>cuDriverGetVersion)(&driver_ver)
 *     if err != 0:
*/
    __pyx_t_4 = NULL;
    __pyx_t_9 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_Did_not_find_cuDriverGetVersion};
      __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_RuntimeError)), __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 47, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __PYX_ERR(0, 47, __pyx_L1_error)

    /* "cuda/bindings/_internal/_nvml.pyx":46
 *         raise NotSupportedError(f'CUDA driver is not found ({err_msg.decode()})')
 *     cuDriverGetVersion = dlsym(handle, "cuDriverGetVersion")
 *     if cuDriverGetVersion == NULL:             # <<<<<<<<<<<<<<
 *         raise RuntimeError('Did not find cuDriverGetVersion symbol in libcuda.so.1')
 *     err = (<int (*)(int*) noexcept nogil>cuDriverGetVersion)(&driver_ver)
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":48
 *     if cuDriverGetVersion == NULL:
 *         raise RuntimeError('Did not find cuDriverGetVersion symbol in libcuda.so.1')
 *     err = (<int (*)(int*) noexcept nogil>cuDriverGetVersion)(&driver_ver)             # <<<<<<<<<<<<<<
 *     if err != 0:
 *         raise RuntimeError(f'cuDriverGetVersion returned error code {err}')
*/
  __pyx_v_err = ((int (*)(int *))__pyx_v_cuDriverGetVersion)((&__pyx_v_driver_ver));

  /* "cuda/bindings/_internal/_nvml.pyx":49
 *         raise RuntimeError('Did not find cuDriverGetVersion symbol in libcuda.so.1')
 *     err = (<int (*)(int*) noexcept nogil>cuDriverGetVersion)(&driver_ver)
 *     if err != 0:             # <<<<<<<<<<<<<<
 *         raise RuntimeError(f'cuDriverGetVersion returned error code {err}')
 * 
*/
  __pyx_t_1 = (__pyx_v_err != 0);
  if (unlikely(__pyx_t_1)) {

    /* "cuda/bindings/_internal/_nvml.pyx":50
 *     err = (<int (*)(int*) noexcept nogil>cuDriverGetVersion)(&driver_ver)
 *     if err != 0:
 *         raise RuntimeError(f'cuDriverGetVersion returned error code {err}')             # <<<<<<<<<<<<<<
 * 
 *     return driver_ver
*/
    __pyx_t_4 = NULL;
    __pyx_t_8 = __Pyx_PyUnicode_From_int(__pyx_v_err, 0, ' ', 'd'); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 50, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_cuDriverGetVersion_returned_erro, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 50, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_9 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3};
      __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_RuntimeError)), __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 50, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __PYX_ERR(0, 50, __pyx_L1_error)

    /* "cuda/bindings/_internal/_nvml.pyx":49
 *         raise RuntimeError('Did not find cuDriverGetVersion symbol in libcuda.so.1')
 *     err = (<int (*)(int*) noexcept nogil>cuDriverGetVersion)(&driver_ver)
 *     if err != 0:             # <<<<<<<<<<<<<<
 *         raise RuntimeError(f'cuDriverGetVersion returned error code {err}')
 * 
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":52
 *         raise RuntimeError(f'cuDriverGetVersion returned error code {err}')
 * 
 *     return driver_ver             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __pyx_r = __pyx_v_driver_ver;
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":36
 *     const void* RTLD_DEFAULT 'RTLD_DEFAULT'
 * 
 * cdef int get_cuda_version():             # <<<<<<<<<<<<<<
 *     cdef void* handle = NULL
 *     cdef int err, driver_ver = 0
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml.get_cuda_version", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":412
 * 
 * 
 * cdef void* load_library() except* with gil:             # <<<<<<<<<<<<<<
 *     return dlopen("libnvidia-ml.so.1", RTLD_NOW | RTLD_GLOBAL)
 * 
*/

static void *__pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(void) {
  void *__pyx_r;
  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();

  /* "cuda/bindings/_internal/_nvml.pyx":413
 * 
 * cdef void* load_library() except* with gil:
 *     return dlopen("libnvidia-ml.so.1", RTLD_NOW | RTLD_GLOBAL)             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __pyx_r = dlopen(__pyx_k_libnvidia_ml_so_1, (RTLD_NOW | RTLD_GLOBAL));
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":412
 * 
 * 
 * cdef void* load_library() except* with gil:             # <<<<<<<<<<<<<<
 *     return dlopen("libnvidia-ml.so.1", RTLD_NOW | RTLD_GLOBAL)
 * 
*/

  /* function exit code */
  __pyx_L0:;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":416
 * 
 * 
 * cdef int _init_nvml() except -1 nogil:             # <<<<<<<<<<<<<<
 *     global __py_nvml_init
 *     cdef void* handle = NULL
*/

static int __pyx_f_4cuda_8bindings_9_internal_5_nvml__init_nvml(void) {
  void *__pyx_v_handle;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  size_t __pyx_t_5;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  int __pyx_t_9;
  void *__pyx_t_10;
  PyObject *__pyx_t_11 = NULL;
  PyObject *__pyx_t_12 = NULL;
  int __pyx_t_13;
  int __pyx_t_14;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_init_nvml", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":418
 * cdef int _init_nvml() except -1 nogil:
 *     global __py_nvml_init
 *     cdef void* handle = NULL             # <<<<<<<<<<<<<<
 * 
 *     with gil, __symbol_lock:
*/
  __pyx_v_handle = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":420
 *     cdef void* handle = NULL
 * 
 *     with gil, __symbol_lock:             # <<<<<<<<<<<<<<
 *         # Recheck the flag after obtaining the locks
 *         if __py_nvml_init:
*/
  {
      PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
      /*try:*/ {
        /*with:*/ {
          __pyx_t_1 = __Pyx_PyObject_LookupSpecial(__pyx_v_4cuda_8bindings_9_internal_5_nvml___symbol_lock, __pyx_mstate_global->__pyx_n_u_exit); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 420, __pyx_L4_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_3 = NULL;
          __pyx_t_4 = __Pyx_PyObject_LookupSpecial(__pyx_v_4cuda_8bindings_9_internal_5_nvml___symbol_lock, __pyx_mstate_global->__pyx_n_u_enter); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 420, __pyx_L6_error)
          __Pyx_GOTREF(__pyx_t_4);
          __pyx_t_5 = 1;
          #if CYTHON_UNPACK_METHODS
          if (likely(PyMethod_Check(__pyx_t_4))) {
            __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
            assert(__pyx_t_3);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
            __Pyx_INCREF(__pyx_t_3);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
            __pyx_t_5 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
            __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 420, __pyx_L6_error)
            __Pyx_GOTREF(__pyx_t_2);
          }
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          /*try:*/ {
            {
              __Pyx_PyThreadState_declare
              __Pyx_PyThreadState_assign
              __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8);
              __Pyx_XGOTREF(__pyx_t_6);
              __Pyx_XGOTREF(__pyx_t_7);
              __Pyx_XGOTREF(__pyx_t_8);
              /*try:*/ {

                /* "cuda/bindings/_internal/_nvml.pyx":422
 *     with gil, __symbol_lock:
 *         # Recheck the flag after obtaining the locks
 *         if __py_nvml_init:             # <<<<<<<<<<<<<<
 *             return 0
 * 
*/
                if (__pyx_v_4cuda_8bindings_9_internal_5_nvml___py_nvml_init) {

                  /* "cuda/bindings/_internal/_nvml.pyx":423
 *         # Recheck the flag after obtaining the locks
 *         if __py_nvml_init:
 *             return 0             # <<<<<<<<<<<<<<
 * 
 *         # Load function
*/
                  __pyx_r = 0;
                  goto __pyx_L14_try_return;

                  /* "cuda/bindings/_internal/_nvml.pyx":422
 *     with gil, __symbol_lock:
 *         # Recheck the flag after obtaining the locks
 *         if __py_nvml_init:             # <<<<<<<<<<<<<<
 *             return 0
 * 
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":427
 *         # Load function
 *         global __nvmlInit_v2
 *         __nvmlInit_v2 = dlsym(RTLD_DEFAULT, 'nvmlInit_v2')             # <<<<<<<<<<<<<<
 *         if __nvmlInit_v2 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlInit_v2 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlInit_v2);

                /* "cuda/bindings/_internal/_nvml.pyx":428
 *         global __nvmlInit_v2
 *         __nvmlInit_v2 = dlsym(RTLD_DEFAULT, 'nvmlInit_v2')
 *         if __nvmlInit_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlInit_v2 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":429
 *         __nvmlInit_v2 = dlsym(RTLD_DEFAULT, 'nvmlInit_v2')
 *         if __nvmlInit_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlInit_v2 = dlsym(handle, 'nvmlInit_v2')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":430
 *         if __nvmlInit_v2 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlInit_v2 = dlsym(handle, 'nvmlInit_v2')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 430, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":429
 *         __nvmlInit_v2 = dlsym(RTLD_DEFAULT, 'nvmlInit_v2')
 *         if __nvmlInit_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlInit_v2 = dlsym(handle, 'nvmlInit_v2')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":431
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlInit_v2 = dlsym(handle, 'nvmlInit_v2')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlInitWithFlags
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlInit_v2 = dlsym(__pyx_v_handle, __pyx_k_nvmlInit_v2);

                  /* "cuda/bindings/_internal/_nvml.pyx":428
 *         global __nvmlInit_v2
 *         __nvmlInit_v2 = dlsym(RTLD_DEFAULT, 'nvmlInit_v2')
 *         if __nvmlInit_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":434
 * 
 *         global __nvmlInitWithFlags
 *         __nvmlInitWithFlags = dlsym(RTLD_DEFAULT, 'nvmlInitWithFlags')             # <<<<<<<<<<<<<<
 *         if __nvmlInitWithFlags == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlInitWithFlags = dlsym(RTLD_DEFAULT, __pyx_k_nvmlInitWithFlags);

                /* "cuda/bindings/_internal/_nvml.pyx":435
 *         global __nvmlInitWithFlags
 *         __nvmlInitWithFlags = dlsym(RTLD_DEFAULT, 'nvmlInitWithFlags')
 *         if __nvmlInitWithFlags == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlInitWithFlags == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":436
 *         __nvmlInitWithFlags = dlsym(RTLD_DEFAULT, 'nvmlInitWithFlags')
 *         if __nvmlInitWithFlags == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlInitWithFlags = dlsym(handle, 'nvmlInitWithFlags')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":437
 *         if __nvmlInitWithFlags == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlInitWithFlags = dlsym(handle, 'nvmlInitWithFlags')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 437, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":436
 *         __nvmlInitWithFlags = dlsym(RTLD_DEFAULT, 'nvmlInitWithFlags')
 *         if __nvmlInitWithFlags == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlInitWithFlags = dlsym(handle, 'nvmlInitWithFlags')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":438
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlInitWithFlags = dlsym(handle, 'nvmlInitWithFlags')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlShutdown
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlInitWithFlags = dlsym(__pyx_v_handle, __pyx_k_nvmlInitWithFlags);

                  /* "cuda/bindings/_internal/_nvml.pyx":435
 *         global __nvmlInitWithFlags
 *         __nvmlInitWithFlags = dlsym(RTLD_DEFAULT, 'nvmlInitWithFlags')
 *         if __nvmlInitWithFlags == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":441
 * 
 *         global __nvmlShutdown
 *         __nvmlShutdown = dlsym(RTLD_DEFAULT, 'nvmlShutdown')             # <<<<<<<<<<<<<<
 *         if __nvmlShutdown == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlShutdown = dlsym(RTLD_DEFAULT, __pyx_k_nvmlShutdown);

                /* "cuda/bindings/_internal/_nvml.pyx":442
 *         global __nvmlShutdown
 *         __nvmlShutdown = dlsym(RTLD_DEFAULT, 'nvmlShutdown')
 *         if __nvmlShutdown == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlShutdown == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":443
 *         __nvmlShutdown = dlsym(RTLD_DEFAULT, 'nvmlShutdown')
 *         if __nvmlShutdown == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlShutdown = dlsym(handle, 'nvmlShutdown')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":444
 *         if __nvmlShutdown == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlShutdown = dlsym(handle, 'nvmlShutdown')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 444, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":443
 *         __nvmlShutdown = dlsym(RTLD_DEFAULT, 'nvmlShutdown')
 *         if __nvmlShutdown == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlShutdown = dlsym(handle, 'nvmlShutdown')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":445
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlShutdown = dlsym(handle, 'nvmlShutdown')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlErrorString
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlShutdown = dlsym(__pyx_v_handle, __pyx_k_nvmlShutdown);

                  /* "cuda/bindings/_internal/_nvml.pyx":442
 *         global __nvmlShutdown
 *         __nvmlShutdown = dlsym(RTLD_DEFAULT, 'nvmlShutdown')
 *         if __nvmlShutdown == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":448
 * 
 *         global __nvmlErrorString
 *         __nvmlErrorString = dlsym(RTLD_DEFAULT, 'nvmlErrorString')             # <<<<<<<<<<<<<<
 *         if __nvmlErrorString == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlErrorString = dlsym(RTLD_DEFAULT, __pyx_k_nvmlErrorString);

                /* "cuda/bindings/_internal/_nvml.pyx":449
 *         global __nvmlErrorString
 *         __nvmlErrorString = dlsym(RTLD_DEFAULT, 'nvmlErrorString')
 *         if __nvmlErrorString == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlErrorString == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":450
 *         __nvmlErrorString = dlsym(RTLD_DEFAULT, 'nvmlErrorString')
 *         if __nvmlErrorString == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlErrorString = dlsym(handle, 'nvmlErrorString')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":451
 *         if __nvmlErrorString == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlErrorString = dlsym(handle, 'nvmlErrorString')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 451, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":450
 *         __nvmlErrorString = dlsym(RTLD_DEFAULT, 'nvmlErrorString')
 *         if __nvmlErrorString == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlErrorString = dlsym(handle, 'nvmlErrorString')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":452
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlErrorString = dlsym(handle, 'nvmlErrorString')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlSystemGetDriverVersion
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlErrorString = dlsym(__pyx_v_handle, __pyx_k_nvmlErrorString);

                  /* "cuda/bindings/_internal/_nvml.pyx":449
 *         global __nvmlErrorString
 *         __nvmlErrorString = dlsym(RTLD_DEFAULT, 'nvmlErrorString')
 *         if __nvmlErrorString == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":455
 * 
 *         global __nvmlSystemGetDriverVersion
 *         __nvmlSystemGetDriverVersion = dlsym(RTLD_DEFAULT, 'nvmlSystemGetDriverVersion')             # <<<<<<<<<<<<<<
 *         if __nvmlSystemGetDriverVersion == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetDriverVersion = dlsym(RTLD_DEFAULT, __pyx_k_nvmlSystemGetDriverVersion);

                /* "cuda/bindings/_internal/_nvml.pyx":456
 *         global __nvmlSystemGetDriverVersion
 *         __nvmlSystemGetDriverVersion = dlsym(RTLD_DEFAULT, 'nvmlSystemGetDriverVersion')
 *         if __nvmlSystemGetDriverVersion == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetDriverVersion == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":457
 *         __nvmlSystemGetDriverVersion = dlsym(RTLD_DEFAULT, 'nvmlSystemGetDriverVersion')
 *         if __nvmlSystemGetDriverVersion == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetDriverVersion = dlsym(handle, 'nvmlSystemGetDriverVersion')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":458
 *         if __nvmlSystemGetDriverVersion == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlSystemGetDriverVersion = dlsym(handle, 'nvmlSystemGetDriverVersion')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 458, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":457
 *         __nvmlSystemGetDriverVersion = dlsym(RTLD_DEFAULT, 'nvmlSystemGetDriverVersion')
 *         if __nvmlSystemGetDriverVersion == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetDriverVersion = dlsym(handle, 'nvmlSystemGetDriverVersion')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":459
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlSystemGetDriverVersion = dlsym(handle, 'nvmlSystemGetDriverVersion')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlSystemGetNVMLVersion
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetDriverVersion = dlsym(__pyx_v_handle, __pyx_k_nvmlSystemGetDriverVersion);

                  /* "cuda/bindings/_internal/_nvml.pyx":456
 *         global __nvmlSystemGetDriverVersion
 *         __nvmlSystemGetDriverVersion = dlsym(RTLD_DEFAULT, 'nvmlSystemGetDriverVersion')
 *         if __nvmlSystemGetDriverVersion == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":462
 * 
 *         global __nvmlSystemGetNVMLVersion
 *         __nvmlSystemGetNVMLVersion = dlsym(RTLD_DEFAULT, 'nvmlSystemGetNVMLVersion')             # <<<<<<<<<<<<<<
 *         if __nvmlSystemGetNVMLVersion == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetNVMLVersion = dlsym(RTLD_DEFAULT, __pyx_k_nvmlSystemGetNVMLVersion);

                /* "cuda/bindings/_internal/_nvml.pyx":463
 *         global __nvmlSystemGetNVMLVersion
 *         __nvmlSystemGetNVMLVersion = dlsym(RTLD_DEFAULT, 'nvmlSystemGetNVMLVersion')
 *         if __nvmlSystemGetNVMLVersion == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetNVMLVersion == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":464
 *         __nvmlSystemGetNVMLVersion = dlsym(RTLD_DEFAULT, 'nvmlSystemGetNVMLVersion')
 *         if __nvmlSystemGetNVMLVersion == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetNVMLVersion = dlsym(handle, 'nvmlSystemGetNVMLVersion')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":465
 *         if __nvmlSystemGetNVMLVersion == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlSystemGetNVMLVersion = dlsym(handle, 'nvmlSystemGetNVMLVersion')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 465, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":464
 *         __nvmlSystemGetNVMLVersion = dlsym(RTLD_DEFAULT, 'nvmlSystemGetNVMLVersion')
 *         if __nvmlSystemGetNVMLVersion == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetNVMLVersion = dlsym(handle, 'nvmlSystemGetNVMLVersion')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":466
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlSystemGetNVMLVersion = dlsym(handle, 'nvmlSystemGetNVMLVersion')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlSystemGetCudaDriverVersion
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetNVMLVersion = dlsym(__pyx_v_handle, __pyx_k_nvmlSystemGetNVMLVersion);

                  /* "cuda/bindings/_internal/_nvml.pyx":463
 *         global __nvmlSystemGetNVMLVersion
 *         __nvmlSystemGetNVMLVersion = dlsym(RTLD_DEFAULT, 'nvmlSystemGetNVMLVersion')
 *         if __nvmlSystemGetNVMLVersion == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":469
 * 
 *         global __nvmlSystemGetCudaDriverVersion
 *         __nvmlSystemGetCudaDriverVersion = dlsym(RTLD_DEFAULT, 'nvmlSystemGetCudaDriverVersion')             # <<<<<<<<<<<<<<
 *         if __nvmlSystemGetCudaDriverVersion == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetCudaDriverVersion = dlsym(RTLD_DEFAULT, __pyx_k_nvmlSystemGetCudaDriverVersion);

                /* "cuda/bindings/_internal/_nvml.pyx":470
 *         global __nvmlSystemGetCudaDriverVersion
 *         __nvmlSystemGetCudaDriverVersion = dlsym(RTLD_DEFAULT, 'nvmlSystemGetCudaDriverVersion')
 *         if __nvmlSystemGetCudaDriverVersion == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetCudaDriverVersion == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":471
 *         __nvmlSystemGetCudaDriverVersion = dlsym(RTLD_DEFAULT, 'nvmlSystemGetCudaDriverVersion')
 *         if __nvmlSystemGetCudaDriverVersion == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetCudaDriverVersion = dlsym(handle, 'nvmlSystemGetCudaDriverVersion')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":472
 *         if __nvmlSystemGetCudaDriverVersion == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlSystemGetCudaDriverVersion = dlsym(handle, 'nvmlSystemGetCudaDriverVersion')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 472, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":471
 *         __nvmlSystemGetCudaDriverVersion = dlsym(RTLD_DEFAULT, 'nvmlSystemGetCudaDriverVersion')
 *         if __nvmlSystemGetCudaDriverVersion == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetCudaDriverVersion = dlsym(handle, 'nvmlSystemGetCudaDriverVersion')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":473
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlSystemGetCudaDriverVersion = dlsym(handle, 'nvmlSystemGetCudaDriverVersion')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlSystemGetCudaDriverVersion_v2
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetCudaDriverVersion = dlsym(__pyx_v_handle, __pyx_k_nvmlSystemGetCudaDriverVersion);

                  /* "cuda/bindings/_internal/_nvml.pyx":470
 *         global __nvmlSystemGetCudaDriverVersion
 *         __nvmlSystemGetCudaDriverVersion = dlsym(RTLD_DEFAULT, 'nvmlSystemGetCudaDriverVersion')
 *         if __nvmlSystemGetCudaDriverVersion == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":476
 * 
 *         global __nvmlSystemGetCudaDriverVersion_v2
 *         __nvmlSystemGetCudaDriverVersion_v2 = dlsym(RTLD_DEFAULT, 'nvmlSystemGetCudaDriverVersion_v2')             # <<<<<<<<<<<<<<
 *         if __nvmlSystemGetCudaDriverVersion_v2 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetCudaDriverVersion_v2 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlSystemGetCudaDriverVersion_v);

                /* "cuda/bindings/_internal/_nvml.pyx":477
 *         global __nvmlSystemGetCudaDriverVersion_v2
 *         __nvmlSystemGetCudaDriverVersion_v2 = dlsym(RTLD_DEFAULT, 'nvmlSystemGetCudaDriverVersion_v2')
 *         if __nvmlSystemGetCudaDriverVersion_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetCudaDriverVersion_v2 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":478
 *         __nvmlSystemGetCudaDriverVersion_v2 = dlsym(RTLD_DEFAULT, 'nvmlSystemGetCudaDriverVersion_v2')
 *         if __nvmlSystemGetCudaDriverVersion_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetCudaDriverVersion_v2 = dlsym(handle, 'nvmlSystemGetCudaDriverVersion_v2')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":479
 *         if __nvmlSystemGetCudaDriverVersion_v2 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlSystemGetCudaDriverVersion_v2 = dlsym(handle, 'nvmlSystemGetCudaDriverVersion_v2')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 479, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":478
 *         __nvmlSystemGetCudaDriverVersion_v2 = dlsym(RTLD_DEFAULT, 'nvmlSystemGetCudaDriverVersion_v2')
 *         if __nvmlSystemGetCudaDriverVersion_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetCudaDriverVersion_v2 = dlsym(handle, 'nvmlSystemGetCudaDriverVersion_v2')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":480
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlSystemGetCudaDriverVersion_v2 = dlsym(handle, 'nvmlSystemGetCudaDriverVersion_v2')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlSystemGetProcessName
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetCudaDriverVersion_v2 = dlsym(__pyx_v_handle, __pyx_k_nvmlSystemGetCudaDriverVersion_v);

                  /* "cuda/bindings/_internal/_nvml.pyx":477
 *         global __nvmlSystemGetCudaDriverVersion_v2
 *         __nvmlSystemGetCudaDriverVersion_v2 = dlsym(RTLD_DEFAULT, 'nvmlSystemGetCudaDriverVersion_v2')
 *         if __nvmlSystemGetCudaDriverVersion_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":483
 * 
 *         global __nvmlSystemGetProcessName
 *         __nvmlSystemGetProcessName = dlsym(RTLD_DEFAULT, 'nvmlSystemGetProcessName')             # <<<<<<<<<<<<<<
 *         if __nvmlSystemGetProcessName == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetProcessName = dlsym(RTLD_DEFAULT, __pyx_k_nvmlSystemGetProcessName);

                /* "cuda/bindings/_internal/_nvml.pyx":484
 *         global __nvmlSystemGetProcessName
 *         __nvmlSystemGetProcessName = dlsym(RTLD_DEFAULT, 'nvmlSystemGetProcessName')
 *         if __nvmlSystemGetProcessName == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetProcessName == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":485
 *         __nvmlSystemGetProcessName = dlsym(RTLD_DEFAULT, 'nvmlSystemGetProcessName')
 *         if __nvmlSystemGetProcessName == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetProcessName = dlsym(handle, 'nvmlSystemGetProcessName')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":486
 *         if __nvmlSystemGetProcessName == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlSystemGetProcessName = dlsym(handle, 'nvmlSystemGetProcessName')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 486, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":485
 *         __nvmlSystemGetProcessName = dlsym(RTLD_DEFAULT, 'nvmlSystemGetProcessName')
 *         if __nvmlSystemGetProcessName == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetProcessName = dlsym(handle, 'nvmlSystemGetProcessName')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":487
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlSystemGetProcessName = dlsym(handle, 'nvmlSystemGetProcessName')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlSystemGetHicVersion
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetProcessName = dlsym(__pyx_v_handle, __pyx_k_nvmlSystemGetProcessName);

                  /* "cuda/bindings/_internal/_nvml.pyx":484
 *         global __nvmlSystemGetProcessName
 *         __nvmlSystemGetProcessName = dlsym(RTLD_DEFAULT, 'nvmlSystemGetProcessName')
 *         if __nvmlSystemGetProcessName == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":490
 * 
 *         global __nvmlSystemGetHicVersion
 *         __nvmlSystemGetHicVersion = dlsym(RTLD_DEFAULT, 'nvmlSystemGetHicVersion')             # <<<<<<<<<<<<<<
 *         if __nvmlSystemGetHicVersion == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetHicVersion = dlsym(RTLD_DEFAULT, __pyx_k_nvmlSystemGetHicVersion);

                /* "cuda/bindings/_internal/_nvml.pyx":491
 *         global __nvmlSystemGetHicVersion
 *         __nvmlSystemGetHicVersion = dlsym(RTLD_DEFAULT, 'nvmlSystemGetHicVersion')
 *         if __nvmlSystemGetHicVersion == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetHicVersion == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":492
 *         __nvmlSystemGetHicVersion = dlsym(RTLD_DEFAULT, 'nvmlSystemGetHicVersion')
 *         if __nvmlSystemGetHicVersion == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetHicVersion = dlsym(handle, 'nvmlSystemGetHicVersion')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":493
 *         if __nvmlSystemGetHicVersion == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlSystemGetHicVersion = dlsym(handle, 'nvmlSystemGetHicVersion')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 493, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":492
 *         __nvmlSystemGetHicVersion = dlsym(RTLD_DEFAULT, 'nvmlSystemGetHicVersion')
 *         if __nvmlSystemGetHicVersion == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetHicVersion = dlsym(handle, 'nvmlSystemGetHicVersion')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":494
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlSystemGetHicVersion = dlsym(handle, 'nvmlSystemGetHicVersion')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlSystemGetTopologyGpuSet
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetHicVersion = dlsym(__pyx_v_handle, __pyx_k_nvmlSystemGetHicVersion);

                  /* "cuda/bindings/_internal/_nvml.pyx":491
 *         global __nvmlSystemGetHicVersion
 *         __nvmlSystemGetHicVersion = dlsym(RTLD_DEFAULT, 'nvmlSystemGetHicVersion')
 *         if __nvmlSystemGetHicVersion == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":497
 * 
 *         global __nvmlSystemGetTopologyGpuSet
 *         __nvmlSystemGetTopologyGpuSet = dlsym(RTLD_DEFAULT, 'nvmlSystemGetTopologyGpuSet')             # <<<<<<<<<<<<<<
 *         if __nvmlSystemGetTopologyGpuSet == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetTopologyGpuSet = dlsym(RTLD_DEFAULT, __pyx_k_nvmlSystemGetTopologyGpuSet);

                /* "cuda/bindings/_internal/_nvml.pyx":498
 *         global __nvmlSystemGetTopologyGpuSet
 *         __nvmlSystemGetTopologyGpuSet = dlsym(RTLD_DEFAULT, 'nvmlSystemGetTopologyGpuSet')
 *         if __nvmlSystemGetTopologyGpuSet == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetTopologyGpuSet == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":499
 *         __nvmlSystemGetTopologyGpuSet = dlsym(RTLD_DEFAULT, 'nvmlSystemGetTopologyGpuSet')
 *         if __nvmlSystemGetTopologyGpuSet == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetTopologyGpuSet = dlsym(handle, 'nvmlSystemGetTopologyGpuSet')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":500
 *         if __nvmlSystemGetTopologyGpuSet == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlSystemGetTopologyGpuSet = dlsym(handle, 'nvmlSystemGetTopologyGpuSet')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 500, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":499
 *         __nvmlSystemGetTopologyGpuSet = dlsym(RTLD_DEFAULT, 'nvmlSystemGetTopologyGpuSet')
 *         if __nvmlSystemGetTopologyGpuSet == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetTopologyGpuSet = dlsym(handle, 'nvmlSystemGetTopologyGpuSet')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":501
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlSystemGetTopologyGpuSet = dlsym(handle, 'nvmlSystemGetTopologyGpuSet')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlSystemGetDriverBranch
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetTopologyGpuSet = dlsym(__pyx_v_handle, __pyx_k_nvmlSystemGetTopologyGpuSet);

                  /* "cuda/bindings/_internal/_nvml.pyx":498
 *         global __nvmlSystemGetTopologyGpuSet
 *         __nvmlSystemGetTopologyGpuSet = dlsym(RTLD_DEFAULT, 'nvmlSystemGetTopologyGpuSet')
 *         if __nvmlSystemGetTopologyGpuSet == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":504
 * 
 *         global __nvmlSystemGetDriverBranch
 *         __nvmlSystemGetDriverBranch = dlsym(RTLD_DEFAULT, 'nvmlSystemGetDriverBranch')             # <<<<<<<<<<<<<<
 *         if __nvmlSystemGetDriverBranch == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetDriverBranch = dlsym(RTLD_DEFAULT, __pyx_k_nvmlSystemGetDriverBranch);

                /* "cuda/bindings/_internal/_nvml.pyx":505
 *         global __nvmlSystemGetDriverBranch
 *         __nvmlSystemGetDriverBranch = dlsym(RTLD_DEFAULT, 'nvmlSystemGetDriverBranch')
 *         if __nvmlSystemGetDriverBranch == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetDriverBranch == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":506
 *         __nvmlSystemGetDriverBranch = dlsym(RTLD_DEFAULT, 'nvmlSystemGetDriverBranch')
 *         if __nvmlSystemGetDriverBranch == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetDriverBranch = dlsym(handle, 'nvmlSystemGetDriverBranch')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":507
 *         if __nvmlSystemGetDriverBranch == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlSystemGetDriverBranch = dlsym(handle, 'nvmlSystemGetDriverBranch')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 507, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":506
 *         __nvmlSystemGetDriverBranch = dlsym(RTLD_DEFAULT, 'nvmlSystemGetDriverBranch')
 *         if __nvmlSystemGetDriverBranch == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetDriverBranch = dlsym(handle, 'nvmlSystemGetDriverBranch')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":508
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlSystemGetDriverBranch = dlsym(handle, 'nvmlSystemGetDriverBranch')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlUnitGetCount
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetDriverBranch = dlsym(__pyx_v_handle, __pyx_k_nvmlSystemGetDriverBranch);

                  /* "cuda/bindings/_internal/_nvml.pyx":505
 *         global __nvmlSystemGetDriverBranch
 *         __nvmlSystemGetDriverBranch = dlsym(RTLD_DEFAULT, 'nvmlSystemGetDriverBranch')
 *         if __nvmlSystemGetDriverBranch == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":511
 * 
 *         global __nvmlUnitGetCount
 *         __nvmlUnitGetCount = dlsym(RTLD_DEFAULT, 'nvmlUnitGetCount')             # <<<<<<<<<<<<<<
 *         if __nvmlUnitGetCount == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetCount = dlsym(RTLD_DEFAULT, __pyx_k_nvmlUnitGetCount);

                /* "cuda/bindings/_internal/_nvml.pyx":512
 *         global __nvmlUnitGetCount
 *         __nvmlUnitGetCount = dlsym(RTLD_DEFAULT, 'nvmlUnitGetCount')
 *         if __nvmlUnitGetCount == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetCount == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":513
 *         __nvmlUnitGetCount = dlsym(RTLD_DEFAULT, 'nvmlUnitGetCount')
 *         if __nvmlUnitGetCount == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlUnitGetCount = dlsym(handle, 'nvmlUnitGetCount')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":514
 *         if __nvmlUnitGetCount == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlUnitGetCount = dlsym(handle, 'nvmlUnitGetCount')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 514, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":513
 *         __nvmlUnitGetCount = dlsym(RTLD_DEFAULT, 'nvmlUnitGetCount')
 *         if __nvmlUnitGetCount == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlUnitGetCount = dlsym(handle, 'nvmlUnitGetCount')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":515
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlUnitGetCount = dlsym(handle, 'nvmlUnitGetCount')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlUnitGetHandleByIndex
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetCount = dlsym(__pyx_v_handle, __pyx_k_nvmlUnitGetCount);

                  /* "cuda/bindings/_internal/_nvml.pyx":512
 *         global __nvmlUnitGetCount
 *         __nvmlUnitGetCount = dlsym(RTLD_DEFAULT, 'nvmlUnitGetCount')
 *         if __nvmlUnitGetCount == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":518
 * 
 *         global __nvmlUnitGetHandleByIndex
 *         __nvmlUnitGetHandleByIndex = dlsym(RTLD_DEFAULT, 'nvmlUnitGetHandleByIndex')             # <<<<<<<<<<<<<<
 *         if __nvmlUnitGetHandleByIndex == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetHandleByIndex = dlsym(RTLD_DEFAULT, __pyx_k_nvmlUnitGetHandleByIndex);

                /* "cuda/bindings/_internal/_nvml.pyx":519
 *         global __nvmlUnitGetHandleByIndex
 *         __nvmlUnitGetHandleByIndex = dlsym(RTLD_DEFAULT, 'nvmlUnitGetHandleByIndex')
 *         if __nvmlUnitGetHandleByIndex == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetHandleByIndex == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":520
 *         __nvmlUnitGetHandleByIndex = dlsym(RTLD_DEFAULT, 'nvmlUnitGetHandleByIndex')
 *         if __nvmlUnitGetHandleByIndex == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlUnitGetHandleByIndex = dlsym(handle, 'nvmlUnitGetHandleByIndex')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":521
 *         if __nvmlUnitGetHandleByIndex == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlUnitGetHandleByIndex = dlsym(handle, 'nvmlUnitGetHandleByIndex')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 521, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":520
 *         __nvmlUnitGetHandleByIndex = dlsym(RTLD_DEFAULT, 'nvmlUnitGetHandleByIndex')
 *         if __nvmlUnitGetHandleByIndex == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlUnitGetHandleByIndex = dlsym(handle, 'nvmlUnitGetHandleByIndex')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":522
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlUnitGetHandleByIndex = dlsym(handle, 'nvmlUnitGetHandleByIndex')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlUnitGetUnitInfo
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetHandleByIndex = dlsym(__pyx_v_handle, __pyx_k_nvmlUnitGetHandleByIndex);

                  /* "cuda/bindings/_internal/_nvml.pyx":519
 *         global __nvmlUnitGetHandleByIndex
 *         __nvmlUnitGetHandleByIndex = dlsym(RTLD_DEFAULT, 'nvmlUnitGetHandleByIndex')
 *         if __nvmlUnitGetHandleByIndex == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":525
 * 
 *         global __nvmlUnitGetUnitInfo
 *         __nvmlUnitGetUnitInfo = dlsym(RTLD_DEFAULT, 'nvmlUnitGetUnitInfo')             # <<<<<<<<<<<<<<
 *         if __nvmlUnitGetUnitInfo == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetUnitInfo = dlsym(RTLD_DEFAULT, __pyx_k_nvmlUnitGetUnitInfo);

                /* "cuda/bindings/_internal/_nvml.pyx":526
 *         global __nvmlUnitGetUnitInfo
 *         __nvmlUnitGetUnitInfo = dlsym(RTLD_DEFAULT, 'nvmlUnitGetUnitInfo')
 *         if __nvmlUnitGetUnitInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetUnitInfo == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":527
 *         __nvmlUnitGetUnitInfo = dlsym(RTLD_DEFAULT, 'nvmlUnitGetUnitInfo')
 *         if __nvmlUnitGetUnitInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlUnitGetUnitInfo = dlsym(handle, 'nvmlUnitGetUnitInfo')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":528
 *         if __nvmlUnitGetUnitInfo == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlUnitGetUnitInfo = dlsym(handle, 'nvmlUnitGetUnitInfo')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 528, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":527
 *         __nvmlUnitGetUnitInfo = dlsym(RTLD_DEFAULT, 'nvmlUnitGetUnitInfo')
 *         if __nvmlUnitGetUnitInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlUnitGetUnitInfo = dlsym(handle, 'nvmlUnitGetUnitInfo')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":529
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlUnitGetUnitInfo = dlsym(handle, 'nvmlUnitGetUnitInfo')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlUnitGetLedState
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetUnitInfo = dlsym(__pyx_v_handle, __pyx_k_nvmlUnitGetUnitInfo);

                  /* "cuda/bindings/_internal/_nvml.pyx":526
 *         global __nvmlUnitGetUnitInfo
 *         __nvmlUnitGetUnitInfo = dlsym(RTLD_DEFAULT, 'nvmlUnitGetUnitInfo')
 *         if __nvmlUnitGetUnitInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":532
 * 
 *         global __nvmlUnitGetLedState
 *         __nvmlUnitGetLedState = dlsym(RTLD_DEFAULT, 'nvmlUnitGetLedState')             # <<<<<<<<<<<<<<
 *         if __nvmlUnitGetLedState == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetLedState = dlsym(RTLD_DEFAULT, __pyx_k_nvmlUnitGetLedState);

                /* "cuda/bindings/_internal/_nvml.pyx":533
 *         global __nvmlUnitGetLedState
 *         __nvmlUnitGetLedState = dlsym(RTLD_DEFAULT, 'nvmlUnitGetLedState')
 *         if __nvmlUnitGetLedState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetLedState == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":534
 *         __nvmlUnitGetLedState = dlsym(RTLD_DEFAULT, 'nvmlUnitGetLedState')
 *         if __nvmlUnitGetLedState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlUnitGetLedState = dlsym(handle, 'nvmlUnitGetLedState')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":535
 *         if __nvmlUnitGetLedState == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlUnitGetLedState = dlsym(handle, 'nvmlUnitGetLedState')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 535, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":534
 *         __nvmlUnitGetLedState = dlsym(RTLD_DEFAULT, 'nvmlUnitGetLedState')
 *         if __nvmlUnitGetLedState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlUnitGetLedState = dlsym(handle, 'nvmlUnitGetLedState')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":536
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlUnitGetLedState = dlsym(handle, 'nvmlUnitGetLedState')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlUnitGetPsuInfo
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetLedState = dlsym(__pyx_v_handle, __pyx_k_nvmlUnitGetLedState);

                  /* "cuda/bindings/_internal/_nvml.pyx":533
 *         global __nvmlUnitGetLedState
 *         __nvmlUnitGetLedState = dlsym(RTLD_DEFAULT, 'nvmlUnitGetLedState')
 *         if __nvmlUnitGetLedState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":539
 * 
 *         global __nvmlUnitGetPsuInfo
 *         __nvmlUnitGetPsuInfo = dlsym(RTLD_DEFAULT, 'nvmlUnitGetPsuInfo')             # <<<<<<<<<<<<<<
 *         if __nvmlUnitGetPsuInfo == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetPsuInfo = dlsym(RTLD_DEFAULT, __pyx_k_nvmlUnitGetPsuInfo);

                /* "cuda/bindings/_internal/_nvml.pyx":540
 *         global __nvmlUnitGetPsuInfo
 *         __nvmlUnitGetPsuInfo = dlsym(RTLD_DEFAULT, 'nvmlUnitGetPsuInfo')
 *         if __nvmlUnitGetPsuInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetPsuInfo == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":541
 *         __nvmlUnitGetPsuInfo = dlsym(RTLD_DEFAULT, 'nvmlUnitGetPsuInfo')
 *         if __nvmlUnitGetPsuInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlUnitGetPsuInfo = dlsym(handle, 'nvmlUnitGetPsuInfo')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":542
 *         if __nvmlUnitGetPsuInfo == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlUnitGetPsuInfo = dlsym(handle, 'nvmlUnitGetPsuInfo')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 542, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":541
 *         __nvmlUnitGetPsuInfo = dlsym(RTLD_DEFAULT, 'nvmlUnitGetPsuInfo')
 *         if __nvmlUnitGetPsuInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlUnitGetPsuInfo = dlsym(handle, 'nvmlUnitGetPsuInfo')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":543
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlUnitGetPsuInfo = dlsym(handle, 'nvmlUnitGetPsuInfo')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlUnitGetTemperature
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetPsuInfo = dlsym(__pyx_v_handle, __pyx_k_nvmlUnitGetPsuInfo);

                  /* "cuda/bindings/_internal/_nvml.pyx":540
 *         global __nvmlUnitGetPsuInfo
 *         __nvmlUnitGetPsuInfo = dlsym(RTLD_DEFAULT, 'nvmlUnitGetPsuInfo')
 *         if __nvmlUnitGetPsuInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":546
 * 
 *         global __nvmlUnitGetTemperature
 *         __nvmlUnitGetTemperature = dlsym(RTLD_DEFAULT, 'nvmlUnitGetTemperature')             # <<<<<<<<<<<<<<
 *         if __nvmlUnitGetTemperature == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetTemperature = dlsym(RTLD_DEFAULT, __pyx_k_nvmlUnitGetTemperature);

                /* "cuda/bindings/_internal/_nvml.pyx":547
 *         global __nvmlUnitGetTemperature
 *         __nvmlUnitGetTemperature = dlsym(RTLD_DEFAULT, 'nvmlUnitGetTemperature')
 *         if __nvmlUnitGetTemperature == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetTemperature == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":548
 *         __nvmlUnitGetTemperature = dlsym(RTLD_DEFAULT, 'nvmlUnitGetTemperature')
 *         if __nvmlUnitGetTemperature == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlUnitGetTemperature = dlsym(handle, 'nvmlUnitGetTemperature')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":549
 *         if __nvmlUnitGetTemperature == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlUnitGetTemperature = dlsym(handle, 'nvmlUnitGetTemperature')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 549, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":548
 *         __nvmlUnitGetTemperature = dlsym(RTLD_DEFAULT, 'nvmlUnitGetTemperature')
 *         if __nvmlUnitGetTemperature == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlUnitGetTemperature = dlsym(handle, 'nvmlUnitGetTemperature')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":550
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlUnitGetTemperature = dlsym(handle, 'nvmlUnitGetTemperature')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlUnitGetFanSpeedInfo
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetTemperature = dlsym(__pyx_v_handle, __pyx_k_nvmlUnitGetTemperature);

                  /* "cuda/bindings/_internal/_nvml.pyx":547
 *         global __nvmlUnitGetTemperature
 *         __nvmlUnitGetTemperature = dlsym(RTLD_DEFAULT, 'nvmlUnitGetTemperature')
 *         if __nvmlUnitGetTemperature == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":553
 * 
 *         global __nvmlUnitGetFanSpeedInfo
 *         __nvmlUnitGetFanSpeedInfo = dlsym(RTLD_DEFAULT, 'nvmlUnitGetFanSpeedInfo')             # <<<<<<<<<<<<<<
 *         if __nvmlUnitGetFanSpeedInfo == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetFanSpeedInfo = dlsym(RTLD_DEFAULT, __pyx_k_nvmlUnitGetFanSpeedInfo);

                /* "cuda/bindings/_internal/_nvml.pyx":554
 *         global __nvmlUnitGetFanSpeedInfo
 *         __nvmlUnitGetFanSpeedInfo = dlsym(RTLD_DEFAULT, 'nvmlUnitGetFanSpeedInfo')
 *         if __nvmlUnitGetFanSpeedInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetFanSpeedInfo == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":555
 *         __nvmlUnitGetFanSpeedInfo = dlsym(RTLD_DEFAULT, 'nvmlUnitGetFanSpeedInfo')
 *         if __nvmlUnitGetFanSpeedInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlUnitGetFanSpeedInfo = dlsym(handle, 'nvmlUnitGetFanSpeedInfo')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":556
 *         if __nvmlUnitGetFanSpeedInfo == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlUnitGetFanSpeedInfo = dlsym(handle, 'nvmlUnitGetFanSpeedInfo')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 556, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":555
 *         __nvmlUnitGetFanSpeedInfo = dlsym(RTLD_DEFAULT, 'nvmlUnitGetFanSpeedInfo')
 *         if __nvmlUnitGetFanSpeedInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlUnitGetFanSpeedInfo = dlsym(handle, 'nvmlUnitGetFanSpeedInfo')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":557
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlUnitGetFanSpeedInfo = dlsym(handle, 'nvmlUnitGetFanSpeedInfo')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlUnitGetDevices
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetFanSpeedInfo = dlsym(__pyx_v_handle, __pyx_k_nvmlUnitGetFanSpeedInfo);

                  /* "cuda/bindings/_internal/_nvml.pyx":554
 *         global __nvmlUnitGetFanSpeedInfo
 *         __nvmlUnitGetFanSpeedInfo = dlsym(RTLD_DEFAULT, 'nvmlUnitGetFanSpeedInfo')
 *         if __nvmlUnitGetFanSpeedInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":560
 * 
 *         global __nvmlUnitGetDevices
 *         __nvmlUnitGetDevices = dlsym(RTLD_DEFAULT, 'nvmlUnitGetDevices')             # <<<<<<<<<<<<<<
 *         if __nvmlUnitGetDevices == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetDevices = dlsym(RTLD_DEFAULT, __pyx_k_nvmlUnitGetDevices);

                /* "cuda/bindings/_internal/_nvml.pyx":561
 *         global __nvmlUnitGetDevices
 *         __nvmlUnitGetDevices = dlsym(RTLD_DEFAULT, 'nvmlUnitGetDevices')
 *         if __nvmlUnitGetDevices == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetDevices == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":562
 *         __nvmlUnitGetDevices = dlsym(RTLD_DEFAULT, 'nvmlUnitGetDevices')
 *         if __nvmlUnitGetDevices == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlUnitGetDevices = dlsym(handle, 'nvmlUnitGetDevices')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":563
 *         if __nvmlUnitGetDevices == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlUnitGetDevices = dlsym(handle, 'nvmlUnitGetDevices')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 563, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":562
 *         __nvmlUnitGetDevices = dlsym(RTLD_DEFAULT, 'nvmlUnitGetDevices')
 *         if __nvmlUnitGetDevices == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlUnitGetDevices = dlsym(handle, 'nvmlUnitGetDevices')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":564
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlUnitGetDevices = dlsym(handle, 'nvmlUnitGetDevices')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetCount_v2
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetDevices = dlsym(__pyx_v_handle, __pyx_k_nvmlUnitGetDevices);

                  /* "cuda/bindings/_internal/_nvml.pyx":561
 *         global __nvmlUnitGetDevices
 *         __nvmlUnitGetDevices = dlsym(RTLD_DEFAULT, 'nvmlUnitGetDevices')
 *         if __nvmlUnitGetDevices == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":567
 * 
 *         global __nvmlDeviceGetCount_v2
 *         __nvmlDeviceGetCount_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCount_v2')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetCount_v2 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCount_v2 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetCount_v2);

                /* "cuda/bindings/_internal/_nvml.pyx":568
 *         global __nvmlDeviceGetCount_v2
 *         __nvmlDeviceGetCount_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCount_v2')
 *         if __nvmlDeviceGetCount_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCount_v2 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":569
 *         __nvmlDeviceGetCount_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCount_v2')
 *         if __nvmlDeviceGetCount_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetCount_v2 = dlsym(handle, 'nvmlDeviceGetCount_v2')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":570
 *         if __nvmlDeviceGetCount_v2 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetCount_v2 = dlsym(handle, 'nvmlDeviceGetCount_v2')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 570, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":569
 *         __nvmlDeviceGetCount_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCount_v2')
 *         if __nvmlDeviceGetCount_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetCount_v2 = dlsym(handle, 'nvmlDeviceGetCount_v2')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":571
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetCount_v2 = dlsym(handle, 'nvmlDeviceGetCount_v2')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetAttributes_v2
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCount_v2 = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetCount_v2);

                  /* "cuda/bindings/_internal/_nvml.pyx":568
 *         global __nvmlDeviceGetCount_v2
 *         __nvmlDeviceGetCount_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCount_v2')
 *         if __nvmlDeviceGetCount_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":574
 * 
 *         global __nvmlDeviceGetAttributes_v2
 *         __nvmlDeviceGetAttributes_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAttributes_v2')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetAttributes_v2 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAttributes_v2 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetAttributes_v2);

                /* "cuda/bindings/_internal/_nvml.pyx":575
 *         global __nvmlDeviceGetAttributes_v2
 *         __nvmlDeviceGetAttributes_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAttributes_v2')
 *         if __nvmlDeviceGetAttributes_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAttributes_v2 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":576
 *         __nvmlDeviceGetAttributes_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAttributes_v2')
 *         if __nvmlDeviceGetAttributes_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetAttributes_v2 = dlsym(handle, 'nvmlDeviceGetAttributes_v2')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":577
 *         if __nvmlDeviceGetAttributes_v2 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetAttributes_v2 = dlsym(handle, 'nvmlDeviceGetAttributes_v2')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 577, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":576
 *         __nvmlDeviceGetAttributes_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAttributes_v2')
 *         if __nvmlDeviceGetAttributes_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetAttributes_v2 = dlsym(handle, 'nvmlDeviceGetAttributes_v2')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":578
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetAttributes_v2 = dlsym(handle, 'nvmlDeviceGetAttributes_v2')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetHandleByIndex_v2
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAttributes_v2 = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetAttributes_v2);

                  /* "cuda/bindings/_internal/_nvml.pyx":575
 *         global __nvmlDeviceGetAttributes_v2
 *         __nvmlDeviceGetAttributes_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAttributes_v2')
 *         if __nvmlDeviceGetAttributes_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":581
 * 
 *         global __nvmlDeviceGetHandleByIndex_v2
 *         __nvmlDeviceGetHandleByIndex_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleByIndex_v2')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetHandleByIndex_v2 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByIndex_v2 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetHandleByIndex_v2);

                /* "cuda/bindings/_internal/_nvml.pyx":582
 *         global __nvmlDeviceGetHandleByIndex_v2
 *         __nvmlDeviceGetHandleByIndex_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleByIndex_v2')
 *         if __nvmlDeviceGetHandleByIndex_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByIndex_v2 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":583
 *         __nvmlDeviceGetHandleByIndex_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleByIndex_v2')
 *         if __nvmlDeviceGetHandleByIndex_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetHandleByIndex_v2 = dlsym(handle, 'nvmlDeviceGetHandleByIndex_v2')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":584
 *         if __nvmlDeviceGetHandleByIndex_v2 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetHandleByIndex_v2 = dlsym(handle, 'nvmlDeviceGetHandleByIndex_v2')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 584, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":583
 *         __nvmlDeviceGetHandleByIndex_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleByIndex_v2')
 *         if __nvmlDeviceGetHandleByIndex_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetHandleByIndex_v2 = dlsym(handle, 'nvmlDeviceGetHandleByIndex_v2')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":585
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetHandleByIndex_v2 = dlsym(handle, 'nvmlDeviceGetHandleByIndex_v2')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetHandleBySerial
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByIndex_v2 = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetHandleByIndex_v2);

                  /* "cuda/bindings/_internal/_nvml.pyx":582
 *         global __nvmlDeviceGetHandleByIndex_v2
 *         __nvmlDeviceGetHandleByIndex_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleByIndex_v2')
 *         if __nvmlDeviceGetHandleByIndex_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":588
 * 
 *         global __nvmlDeviceGetHandleBySerial
 *         __nvmlDeviceGetHandleBySerial = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleBySerial')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetHandleBySerial == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleBySerial = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetHandleBySerial);

                /* "cuda/bindings/_internal/_nvml.pyx":589
 *         global __nvmlDeviceGetHandleBySerial
 *         __nvmlDeviceGetHandleBySerial = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleBySerial')
 *         if __nvmlDeviceGetHandleBySerial == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleBySerial == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":590
 *         __nvmlDeviceGetHandleBySerial = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleBySerial')
 *         if __nvmlDeviceGetHandleBySerial == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetHandleBySerial = dlsym(handle, 'nvmlDeviceGetHandleBySerial')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":591
 *         if __nvmlDeviceGetHandleBySerial == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetHandleBySerial = dlsym(handle, 'nvmlDeviceGetHandleBySerial')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 591, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":590
 *         __nvmlDeviceGetHandleBySerial = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleBySerial')
 *         if __nvmlDeviceGetHandleBySerial == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetHandleBySerial = dlsym(handle, 'nvmlDeviceGetHandleBySerial')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":592
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetHandleBySerial = dlsym(handle, 'nvmlDeviceGetHandleBySerial')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetHandleByUUID
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleBySerial = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetHandleBySerial);

                  /* "cuda/bindings/_internal/_nvml.pyx":589
 *         global __nvmlDeviceGetHandleBySerial
 *         __nvmlDeviceGetHandleBySerial = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleBySerial')
 *         if __nvmlDeviceGetHandleBySerial == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":595
 * 
 *         global __nvmlDeviceGetHandleByUUID
 *         __nvmlDeviceGetHandleByUUID = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleByUUID')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetHandleByUUID == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByUUID = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetHandleByUUID);

                /* "cuda/bindings/_internal/_nvml.pyx":596
 *         global __nvmlDeviceGetHandleByUUID
 *         __nvmlDeviceGetHandleByUUID = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleByUUID')
 *         if __nvmlDeviceGetHandleByUUID == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByUUID == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":597
 *         __nvmlDeviceGetHandleByUUID = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleByUUID')
 *         if __nvmlDeviceGetHandleByUUID == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetHandleByUUID = dlsym(handle, 'nvmlDeviceGetHandleByUUID')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":598
 *         if __nvmlDeviceGetHandleByUUID == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetHandleByUUID = dlsym(handle, 'nvmlDeviceGetHandleByUUID')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 598, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":597
 *         __nvmlDeviceGetHandleByUUID = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleByUUID')
 *         if __nvmlDeviceGetHandleByUUID == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetHandleByUUID = dlsym(handle, 'nvmlDeviceGetHandleByUUID')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":599
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetHandleByUUID = dlsym(handle, 'nvmlDeviceGetHandleByUUID')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetHandleByUUIDV
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByUUID = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetHandleByUUID);

                  /* "cuda/bindings/_internal/_nvml.pyx":596
 *         global __nvmlDeviceGetHandleByUUID
 *         __nvmlDeviceGetHandleByUUID = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleByUUID')
 *         if __nvmlDeviceGetHandleByUUID == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":602
 * 
 *         global __nvmlDeviceGetHandleByUUIDV
 *         __nvmlDeviceGetHandleByUUIDV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleByUUIDV')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetHandleByUUIDV == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByUUIDV = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetHandleByUUIDV);

                /* "cuda/bindings/_internal/_nvml.pyx":603
 *         global __nvmlDeviceGetHandleByUUIDV
 *         __nvmlDeviceGetHandleByUUIDV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleByUUIDV')
 *         if __nvmlDeviceGetHandleByUUIDV == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByUUIDV == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":604
 *         __nvmlDeviceGetHandleByUUIDV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleByUUIDV')
 *         if __nvmlDeviceGetHandleByUUIDV == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetHandleByUUIDV = dlsym(handle, 'nvmlDeviceGetHandleByUUIDV')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":605
 *         if __nvmlDeviceGetHandleByUUIDV == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetHandleByUUIDV = dlsym(handle, 'nvmlDeviceGetHandleByUUIDV')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 605, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":604
 *         __nvmlDeviceGetHandleByUUIDV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleByUUIDV')
 *         if __nvmlDeviceGetHandleByUUIDV == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetHandleByUUIDV = dlsym(handle, 'nvmlDeviceGetHandleByUUIDV')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":606
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetHandleByUUIDV = dlsym(handle, 'nvmlDeviceGetHandleByUUIDV')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetHandleByPciBusId_v2
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByUUIDV = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetHandleByUUIDV);

                  /* "cuda/bindings/_internal/_nvml.pyx":603
 *         global __nvmlDeviceGetHandleByUUIDV
 *         __nvmlDeviceGetHandleByUUIDV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleByUUIDV')
 *         if __nvmlDeviceGetHandleByUUIDV == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":609
 * 
 *         global __nvmlDeviceGetHandleByPciBusId_v2
 *         __nvmlDeviceGetHandleByPciBusId_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleByPciBusId_v2')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetHandleByPciBusId_v2 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByPciBusId_v2 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetHandleByPciBusId_v2);

                /* "cuda/bindings/_internal/_nvml.pyx":610
 *         global __nvmlDeviceGetHandleByPciBusId_v2
 *         __nvmlDeviceGetHandleByPciBusId_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleByPciBusId_v2')
 *         if __nvmlDeviceGetHandleByPciBusId_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByPciBusId_v2 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":611
 *         __nvmlDeviceGetHandleByPciBusId_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleByPciBusId_v2')
 *         if __nvmlDeviceGetHandleByPciBusId_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetHandleByPciBusId_v2 = dlsym(handle, 'nvmlDeviceGetHandleByPciBusId_v2')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":612
 *         if __nvmlDeviceGetHandleByPciBusId_v2 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetHandleByPciBusId_v2 = dlsym(handle, 'nvmlDeviceGetHandleByPciBusId_v2')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 612, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":611
 *         __nvmlDeviceGetHandleByPciBusId_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleByPciBusId_v2')
 *         if __nvmlDeviceGetHandleByPciBusId_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetHandleByPciBusId_v2 = dlsym(handle, 'nvmlDeviceGetHandleByPciBusId_v2')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":613
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetHandleByPciBusId_v2 = dlsym(handle, 'nvmlDeviceGetHandleByPciBusId_v2')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetName
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByPciBusId_v2 = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetHandleByPciBusId_v2);

                  /* "cuda/bindings/_internal/_nvml.pyx":610
 *         global __nvmlDeviceGetHandleByPciBusId_v2
 *         __nvmlDeviceGetHandleByPciBusId_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHandleByPciBusId_v2')
 *         if __nvmlDeviceGetHandleByPciBusId_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":616
 * 
 *         global __nvmlDeviceGetName
 *         __nvmlDeviceGetName = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetName')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetName == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetName = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetName);

                /* "cuda/bindings/_internal/_nvml.pyx":617
 *         global __nvmlDeviceGetName
 *         __nvmlDeviceGetName = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetName')
 *         if __nvmlDeviceGetName == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetName == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":618
 *         __nvmlDeviceGetName = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetName')
 *         if __nvmlDeviceGetName == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetName = dlsym(handle, 'nvmlDeviceGetName')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":619
 *         if __nvmlDeviceGetName == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetName = dlsym(handle, 'nvmlDeviceGetName')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 619, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":618
 *         __nvmlDeviceGetName = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetName')
 *         if __nvmlDeviceGetName == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetName = dlsym(handle, 'nvmlDeviceGetName')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":620
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetName = dlsym(handle, 'nvmlDeviceGetName')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetBrand
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetName = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetName);

                  /* "cuda/bindings/_internal/_nvml.pyx":617
 *         global __nvmlDeviceGetName
 *         __nvmlDeviceGetName = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetName')
 *         if __nvmlDeviceGetName == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":623
 * 
 *         global __nvmlDeviceGetBrand
 *         __nvmlDeviceGetBrand = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBrand')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetBrand == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBrand = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetBrand);

                /* "cuda/bindings/_internal/_nvml.pyx":624
 *         global __nvmlDeviceGetBrand
 *         __nvmlDeviceGetBrand = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBrand')
 *         if __nvmlDeviceGetBrand == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBrand == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":625
 *         __nvmlDeviceGetBrand = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBrand')
 *         if __nvmlDeviceGetBrand == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetBrand = dlsym(handle, 'nvmlDeviceGetBrand')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":626
 *         if __nvmlDeviceGetBrand == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetBrand = dlsym(handle, 'nvmlDeviceGetBrand')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 626, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":625
 *         __nvmlDeviceGetBrand = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBrand')
 *         if __nvmlDeviceGetBrand == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetBrand = dlsym(handle, 'nvmlDeviceGetBrand')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":627
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetBrand = dlsym(handle, 'nvmlDeviceGetBrand')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetIndex
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBrand = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetBrand);

                  /* "cuda/bindings/_internal/_nvml.pyx":624
 *         global __nvmlDeviceGetBrand
 *         __nvmlDeviceGetBrand = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBrand')
 *         if __nvmlDeviceGetBrand == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":630
 * 
 *         global __nvmlDeviceGetIndex
 *         __nvmlDeviceGetIndex = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetIndex')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetIndex == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetIndex = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetIndex);

                /* "cuda/bindings/_internal/_nvml.pyx":631
 *         global __nvmlDeviceGetIndex
 *         __nvmlDeviceGetIndex = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetIndex')
 *         if __nvmlDeviceGetIndex == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetIndex == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":632
 *         __nvmlDeviceGetIndex = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetIndex')
 *         if __nvmlDeviceGetIndex == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetIndex = dlsym(handle, 'nvmlDeviceGetIndex')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":633
 *         if __nvmlDeviceGetIndex == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetIndex = dlsym(handle, 'nvmlDeviceGetIndex')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 633, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":632
 *         __nvmlDeviceGetIndex = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetIndex')
 *         if __nvmlDeviceGetIndex == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetIndex = dlsym(handle, 'nvmlDeviceGetIndex')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":634
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetIndex = dlsym(handle, 'nvmlDeviceGetIndex')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetSerial
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetIndex = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetIndex);

                  /* "cuda/bindings/_internal/_nvml.pyx":631
 *         global __nvmlDeviceGetIndex
 *         __nvmlDeviceGetIndex = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetIndex')
 *         if __nvmlDeviceGetIndex == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":637
 * 
 *         global __nvmlDeviceGetSerial
 *         __nvmlDeviceGetSerial = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSerial')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetSerial == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSerial = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetSerial);

                /* "cuda/bindings/_internal/_nvml.pyx":638
 *         global __nvmlDeviceGetSerial
 *         __nvmlDeviceGetSerial = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSerial')
 *         if __nvmlDeviceGetSerial == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSerial == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":639
 *         __nvmlDeviceGetSerial = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSerial')
 *         if __nvmlDeviceGetSerial == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetSerial = dlsym(handle, 'nvmlDeviceGetSerial')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":640
 *         if __nvmlDeviceGetSerial == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetSerial = dlsym(handle, 'nvmlDeviceGetSerial')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 640, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":639
 *         __nvmlDeviceGetSerial = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSerial')
 *         if __nvmlDeviceGetSerial == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetSerial = dlsym(handle, 'nvmlDeviceGetSerial')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":641
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetSerial = dlsym(handle, 'nvmlDeviceGetSerial')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetModuleId
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSerial = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetSerial);

                  /* "cuda/bindings/_internal/_nvml.pyx":638
 *         global __nvmlDeviceGetSerial
 *         __nvmlDeviceGetSerial = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSerial')
 *         if __nvmlDeviceGetSerial == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":644
 * 
 *         global __nvmlDeviceGetModuleId
 *         __nvmlDeviceGetModuleId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetModuleId')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetModuleId == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetModuleId = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetModuleId);

                /* "cuda/bindings/_internal/_nvml.pyx":645
 *         global __nvmlDeviceGetModuleId
 *         __nvmlDeviceGetModuleId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetModuleId')
 *         if __nvmlDeviceGetModuleId == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetModuleId == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":646
 *         __nvmlDeviceGetModuleId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetModuleId')
 *         if __nvmlDeviceGetModuleId == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetModuleId = dlsym(handle, 'nvmlDeviceGetModuleId')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":647
 *         if __nvmlDeviceGetModuleId == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetModuleId = dlsym(handle, 'nvmlDeviceGetModuleId')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 647, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":646
 *         __nvmlDeviceGetModuleId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetModuleId')
 *         if __nvmlDeviceGetModuleId == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetModuleId = dlsym(handle, 'nvmlDeviceGetModuleId')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":648
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetModuleId = dlsym(handle, 'nvmlDeviceGetModuleId')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetC2cModeInfoV
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetModuleId = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetModuleId);

                  /* "cuda/bindings/_internal/_nvml.pyx":645
 *         global __nvmlDeviceGetModuleId
 *         __nvmlDeviceGetModuleId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetModuleId')
 *         if __nvmlDeviceGetModuleId == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":651
 * 
 *         global __nvmlDeviceGetC2cModeInfoV
 *         __nvmlDeviceGetC2cModeInfoV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetC2cModeInfoV')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetC2cModeInfoV == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetC2cModeInfoV = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetC2cModeInfoV);

                /* "cuda/bindings/_internal/_nvml.pyx":652
 *         global __nvmlDeviceGetC2cModeInfoV
 *         __nvmlDeviceGetC2cModeInfoV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetC2cModeInfoV')
 *         if __nvmlDeviceGetC2cModeInfoV == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetC2cModeInfoV == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":653
 *         __nvmlDeviceGetC2cModeInfoV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetC2cModeInfoV')
 *         if __nvmlDeviceGetC2cModeInfoV == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetC2cModeInfoV = dlsym(handle, 'nvmlDeviceGetC2cModeInfoV')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":654
 *         if __nvmlDeviceGetC2cModeInfoV == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetC2cModeInfoV = dlsym(handle, 'nvmlDeviceGetC2cModeInfoV')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 654, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":653
 *         __nvmlDeviceGetC2cModeInfoV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetC2cModeInfoV')
 *         if __nvmlDeviceGetC2cModeInfoV == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetC2cModeInfoV = dlsym(handle, 'nvmlDeviceGetC2cModeInfoV')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":655
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetC2cModeInfoV = dlsym(handle, 'nvmlDeviceGetC2cModeInfoV')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetMemoryAffinity
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetC2cModeInfoV = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetC2cModeInfoV);

                  /* "cuda/bindings/_internal/_nvml.pyx":652
 *         global __nvmlDeviceGetC2cModeInfoV
 *         __nvmlDeviceGetC2cModeInfoV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetC2cModeInfoV')
 *         if __nvmlDeviceGetC2cModeInfoV == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":658
 * 
 *         global __nvmlDeviceGetMemoryAffinity
 *         __nvmlDeviceGetMemoryAffinity = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemoryAffinity')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetMemoryAffinity == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryAffinity = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetMemoryAffinity);

                /* "cuda/bindings/_internal/_nvml.pyx":659
 *         global __nvmlDeviceGetMemoryAffinity
 *         __nvmlDeviceGetMemoryAffinity = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemoryAffinity')
 *         if __nvmlDeviceGetMemoryAffinity == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryAffinity == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":660
 *         __nvmlDeviceGetMemoryAffinity = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemoryAffinity')
 *         if __nvmlDeviceGetMemoryAffinity == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMemoryAffinity = dlsym(handle, 'nvmlDeviceGetMemoryAffinity')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":661
 *         if __nvmlDeviceGetMemoryAffinity == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetMemoryAffinity = dlsym(handle, 'nvmlDeviceGetMemoryAffinity')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 661, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":660
 *         __nvmlDeviceGetMemoryAffinity = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemoryAffinity')
 *         if __nvmlDeviceGetMemoryAffinity == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMemoryAffinity = dlsym(handle, 'nvmlDeviceGetMemoryAffinity')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":662
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetMemoryAffinity = dlsym(handle, 'nvmlDeviceGetMemoryAffinity')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetCpuAffinityWithinScope
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryAffinity = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetMemoryAffinity);

                  /* "cuda/bindings/_internal/_nvml.pyx":659
 *         global __nvmlDeviceGetMemoryAffinity
 *         __nvmlDeviceGetMemoryAffinity = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemoryAffinity')
 *         if __nvmlDeviceGetMemoryAffinity == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":665
 * 
 *         global __nvmlDeviceGetCpuAffinityWithinScope
 *         __nvmlDeviceGetCpuAffinityWithinScope = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCpuAffinityWithinScope')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetCpuAffinityWithinScope == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCpuAffinityWithinScope = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetCpuAffinityWithinSc);

                /* "cuda/bindings/_internal/_nvml.pyx":666
 *         global __nvmlDeviceGetCpuAffinityWithinScope
 *         __nvmlDeviceGetCpuAffinityWithinScope = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCpuAffinityWithinScope')
 *         if __nvmlDeviceGetCpuAffinityWithinScope == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCpuAffinityWithinScope == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":667
 *         __nvmlDeviceGetCpuAffinityWithinScope = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCpuAffinityWithinScope')
 *         if __nvmlDeviceGetCpuAffinityWithinScope == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetCpuAffinityWithinScope = dlsym(handle, 'nvmlDeviceGetCpuAffinityWithinScope')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":668
 *         if __nvmlDeviceGetCpuAffinityWithinScope == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetCpuAffinityWithinScope = dlsym(handle, 'nvmlDeviceGetCpuAffinityWithinScope')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 668, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":667
 *         __nvmlDeviceGetCpuAffinityWithinScope = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCpuAffinityWithinScope')
 *         if __nvmlDeviceGetCpuAffinityWithinScope == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetCpuAffinityWithinScope = dlsym(handle, 'nvmlDeviceGetCpuAffinityWithinScope')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":669
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetCpuAffinityWithinScope = dlsym(handle, 'nvmlDeviceGetCpuAffinityWithinScope')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetCpuAffinity
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCpuAffinityWithinScope = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetCpuAffinityWithinSc);

                  /* "cuda/bindings/_internal/_nvml.pyx":666
 *         global __nvmlDeviceGetCpuAffinityWithinScope
 *         __nvmlDeviceGetCpuAffinityWithinScope = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCpuAffinityWithinScope')
 *         if __nvmlDeviceGetCpuAffinityWithinScope == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":672
 * 
 *         global __nvmlDeviceGetCpuAffinity
 *         __nvmlDeviceGetCpuAffinity = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCpuAffinity')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetCpuAffinity == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCpuAffinity = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetCpuAffinity);

                /* "cuda/bindings/_internal/_nvml.pyx":673
 *         global __nvmlDeviceGetCpuAffinity
 *         __nvmlDeviceGetCpuAffinity = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCpuAffinity')
 *         if __nvmlDeviceGetCpuAffinity == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCpuAffinity == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":674
 *         __nvmlDeviceGetCpuAffinity = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCpuAffinity')
 *         if __nvmlDeviceGetCpuAffinity == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetCpuAffinity = dlsym(handle, 'nvmlDeviceGetCpuAffinity')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":675
 *         if __nvmlDeviceGetCpuAffinity == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetCpuAffinity = dlsym(handle, 'nvmlDeviceGetCpuAffinity')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 675, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":674
 *         __nvmlDeviceGetCpuAffinity = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCpuAffinity')
 *         if __nvmlDeviceGetCpuAffinity == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetCpuAffinity = dlsym(handle, 'nvmlDeviceGetCpuAffinity')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":676
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetCpuAffinity = dlsym(handle, 'nvmlDeviceGetCpuAffinity')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetCpuAffinity
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCpuAffinity = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetCpuAffinity);

                  /* "cuda/bindings/_internal/_nvml.pyx":673
 *         global __nvmlDeviceGetCpuAffinity
 *         __nvmlDeviceGetCpuAffinity = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCpuAffinity')
 *         if __nvmlDeviceGetCpuAffinity == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":679
 * 
 *         global __nvmlDeviceSetCpuAffinity
 *         __nvmlDeviceSetCpuAffinity = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetCpuAffinity')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetCpuAffinity == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetCpuAffinity = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetCpuAffinity);

                /* "cuda/bindings/_internal/_nvml.pyx":680
 *         global __nvmlDeviceSetCpuAffinity
 *         __nvmlDeviceSetCpuAffinity = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetCpuAffinity')
 *         if __nvmlDeviceSetCpuAffinity == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetCpuAffinity == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":681
 *         __nvmlDeviceSetCpuAffinity = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetCpuAffinity')
 *         if __nvmlDeviceSetCpuAffinity == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetCpuAffinity = dlsym(handle, 'nvmlDeviceSetCpuAffinity')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":682
 *         if __nvmlDeviceSetCpuAffinity == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetCpuAffinity = dlsym(handle, 'nvmlDeviceSetCpuAffinity')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 682, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":681
 *         __nvmlDeviceSetCpuAffinity = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetCpuAffinity')
 *         if __nvmlDeviceSetCpuAffinity == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetCpuAffinity = dlsym(handle, 'nvmlDeviceSetCpuAffinity')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":683
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetCpuAffinity = dlsym(handle, 'nvmlDeviceSetCpuAffinity')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceClearCpuAffinity
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetCpuAffinity = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetCpuAffinity);

                  /* "cuda/bindings/_internal/_nvml.pyx":680
 *         global __nvmlDeviceSetCpuAffinity
 *         __nvmlDeviceSetCpuAffinity = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetCpuAffinity')
 *         if __nvmlDeviceSetCpuAffinity == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":686
 * 
 *         global __nvmlDeviceClearCpuAffinity
 *         __nvmlDeviceClearCpuAffinity = dlsym(RTLD_DEFAULT, 'nvmlDeviceClearCpuAffinity')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceClearCpuAffinity == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearCpuAffinity = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceClearCpuAffinity);

                /* "cuda/bindings/_internal/_nvml.pyx":687
 *         global __nvmlDeviceClearCpuAffinity
 *         __nvmlDeviceClearCpuAffinity = dlsym(RTLD_DEFAULT, 'nvmlDeviceClearCpuAffinity')
 *         if __nvmlDeviceClearCpuAffinity == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearCpuAffinity == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":688
 *         __nvmlDeviceClearCpuAffinity = dlsym(RTLD_DEFAULT, 'nvmlDeviceClearCpuAffinity')
 *         if __nvmlDeviceClearCpuAffinity == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceClearCpuAffinity = dlsym(handle, 'nvmlDeviceClearCpuAffinity')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":689
 *         if __nvmlDeviceClearCpuAffinity == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceClearCpuAffinity = dlsym(handle, 'nvmlDeviceClearCpuAffinity')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 689, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":688
 *         __nvmlDeviceClearCpuAffinity = dlsym(RTLD_DEFAULT, 'nvmlDeviceClearCpuAffinity')
 *         if __nvmlDeviceClearCpuAffinity == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceClearCpuAffinity = dlsym(handle, 'nvmlDeviceClearCpuAffinity')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":690
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceClearCpuAffinity = dlsym(handle, 'nvmlDeviceClearCpuAffinity')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetNumaNodeId
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearCpuAffinity = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceClearCpuAffinity);

                  /* "cuda/bindings/_internal/_nvml.pyx":687
 *         global __nvmlDeviceClearCpuAffinity
 *         __nvmlDeviceClearCpuAffinity = dlsym(RTLD_DEFAULT, 'nvmlDeviceClearCpuAffinity')
 *         if __nvmlDeviceClearCpuAffinity == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":693
 * 
 *         global __nvmlDeviceGetNumaNodeId
 *         __nvmlDeviceGetNumaNodeId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNumaNodeId')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetNumaNodeId == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNumaNodeId = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetNumaNodeId);

                /* "cuda/bindings/_internal/_nvml.pyx":694
 *         global __nvmlDeviceGetNumaNodeId
 *         __nvmlDeviceGetNumaNodeId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNumaNodeId')
 *         if __nvmlDeviceGetNumaNodeId == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNumaNodeId == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":695
 *         __nvmlDeviceGetNumaNodeId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNumaNodeId')
 *         if __nvmlDeviceGetNumaNodeId == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetNumaNodeId = dlsym(handle, 'nvmlDeviceGetNumaNodeId')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":696
 *         if __nvmlDeviceGetNumaNodeId == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetNumaNodeId = dlsym(handle, 'nvmlDeviceGetNumaNodeId')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 696, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":695
 *         __nvmlDeviceGetNumaNodeId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNumaNodeId')
 *         if __nvmlDeviceGetNumaNodeId == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetNumaNodeId = dlsym(handle, 'nvmlDeviceGetNumaNodeId')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":697
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetNumaNodeId = dlsym(handle, 'nvmlDeviceGetNumaNodeId')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetTopologyCommonAncestor
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNumaNodeId = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetNumaNodeId);

                  /* "cuda/bindings/_internal/_nvml.pyx":694
 *         global __nvmlDeviceGetNumaNodeId
 *         __nvmlDeviceGetNumaNodeId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNumaNodeId')
 *         if __nvmlDeviceGetNumaNodeId == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":700
 * 
 *         global __nvmlDeviceGetTopologyCommonAncestor
 *         __nvmlDeviceGetTopologyCommonAncestor = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTopologyCommonAncestor')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetTopologyCommonAncestor == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTopologyCommonAncestor = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetTopologyCommonAnces);

                /* "cuda/bindings/_internal/_nvml.pyx":701
 *         global __nvmlDeviceGetTopologyCommonAncestor
 *         __nvmlDeviceGetTopologyCommonAncestor = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTopologyCommonAncestor')
 *         if __nvmlDeviceGetTopologyCommonAncestor == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTopologyCommonAncestor == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":702
 *         __nvmlDeviceGetTopologyCommonAncestor = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTopologyCommonAncestor')
 *         if __nvmlDeviceGetTopologyCommonAncestor == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetTopologyCommonAncestor = dlsym(handle, 'nvmlDeviceGetTopologyCommonAncestor')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":703
 *         if __nvmlDeviceGetTopologyCommonAncestor == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetTopologyCommonAncestor = dlsym(handle, 'nvmlDeviceGetTopologyCommonAncestor')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 703, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":702
 *         __nvmlDeviceGetTopologyCommonAncestor = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTopologyCommonAncestor')
 *         if __nvmlDeviceGetTopologyCommonAncestor == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetTopologyCommonAncestor = dlsym(handle, 'nvmlDeviceGetTopologyCommonAncestor')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":704
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetTopologyCommonAncestor = dlsym(handle, 'nvmlDeviceGetTopologyCommonAncestor')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetTopologyNearestGpus
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTopologyCommonAncestor = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetTopologyCommonAnces);

                  /* "cuda/bindings/_internal/_nvml.pyx":701
 *         global __nvmlDeviceGetTopologyCommonAncestor
 *         __nvmlDeviceGetTopologyCommonAncestor = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTopologyCommonAncestor')
 *         if __nvmlDeviceGetTopologyCommonAncestor == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":707
 * 
 *         global __nvmlDeviceGetTopologyNearestGpus
 *         __nvmlDeviceGetTopologyNearestGpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTopologyNearestGpus')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetTopologyNearestGpus == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTopologyNearestGpus = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetTopologyNearestGpus);

                /* "cuda/bindings/_internal/_nvml.pyx":708
 *         global __nvmlDeviceGetTopologyNearestGpus
 *         __nvmlDeviceGetTopologyNearestGpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTopologyNearestGpus')
 *         if __nvmlDeviceGetTopologyNearestGpus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTopologyNearestGpus == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":709
 *         __nvmlDeviceGetTopologyNearestGpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTopologyNearestGpus')
 *         if __nvmlDeviceGetTopologyNearestGpus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetTopologyNearestGpus = dlsym(handle, 'nvmlDeviceGetTopologyNearestGpus')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":710
 *         if __nvmlDeviceGetTopologyNearestGpus == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetTopologyNearestGpus = dlsym(handle, 'nvmlDeviceGetTopologyNearestGpus')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 710, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":709
 *         __nvmlDeviceGetTopologyNearestGpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTopologyNearestGpus')
 *         if __nvmlDeviceGetTopologyNearestGpus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetTopologyNearestGpus = dlsym(handle, 'nvmlDeviceGetTopologyNearestGpus')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":711
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetTopologyNearestGpus = dlsym(handle, 'nvmlDeviceGetTopologyNearestGpus')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetP2PStatus
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTopologyNearestGpus = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetTopologyNearestGpus);

                  /* "cuda/bindings/_internal/_nvml.pyx":708
 *         global __nvmlDeviceGetTopologyNearestGpus
 *         __nvmlDeviceGetTopologyNearestGpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTopologyNearestGpus')
 *         if __nvmlDeviceGetTopologyNearestGpus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":714
 * 
 *         global __nvmlDeviceGetP2PStatus
 *         __nvmlDeviceGetP2PStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetP2PStatus')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetP2PStatus == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetP2PStatus = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetP2PStatus);

                /* "cuda/bindings/_internal/_nvml.pyx":715
 *         global __nvmlDeviceGetP2PStatus
 *         __nvmlDeviceGetP2PStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetP2PStatus')
 *         if __nvmlDeviceGetP2PStatus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetP2PStatus == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":716
 *         __nvmlDeviceGetP2PStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetP2PStatus')
 *         if __nvmlDeviceGetP2PStatus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetP2PStatus = dlsym(handle, 'nvmlDeviceGetP2PStatus')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":717
 *         if __nvmlDeviceGetP2PStatus == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetP2PStatus = dlsym(handle, 'nvmlDeviceGetP2PStatus')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 717, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":716
 *         __nvmlDeviceGetP2PStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetP2PStatus')
 *         if __nvmlDeviceGetP2PStatus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetP2PStatus = dlsym(handle, 'nvmlDeviceGetP2PStatus')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":718
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetP2PStatus = dlsym(handle, 'nvmlDeviceGetP2PStatus')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetUUID
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetP2PStatus = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetP2PStatus);

                  /* "cuda/bindings/_internal/_nvml.pyx":715
 *         global __nvmlDeviceGetP2PStatus
 *         __nvmlDeviceGetP2PStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetP2PStatus')
 *         if __nvmlDeviceGetP2PStatus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":721
 * 
 *         global __nvmlDeviceGetUUID
 *         __nvmlDeviceGetUUID = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetUUID')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetUUID == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetUUID = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetUUID);

                /* "cuda/bindings/_internal/_nvml.pyx":722
 *         global __nvmlDeviceGetUUID
 *         __nvmlDeviceGetUUID = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetUUID')
 *         if __nvmlDeviceGetUUID == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetUUID == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":723
 *         __nvmlDeviceGetUUID = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetUUID')
 *         if __nvmlDeviceGetUUID == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetUUID = dlsym(handle, 'nvmlDeviceGetUUID')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":724
 *         if __nvmlDeviceGetUUID == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetUUID = dlsym(handle, 'nvmlDeviceGetUUID')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 724, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":723
 *         __nvmlDeviceGetUUID = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetUUID')
 *         if __nvmlDeviceGetUUID == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetUUID = dlsym(handle, 'nvmlDeviceGetUUID')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":725
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetUUID = dlsym(handle, 'nvmlDeviceGetUUID')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetMinorNumber
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetUUID = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetUUID);

                  /* "cuda/bindings/_internal/_nvml.pyx":722
 *         global __nvmlDeviceGetUUID
 *         __nvmlDeviceGetUUID = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetUUID')
 *         if __nvmlDeviceGetUUID == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":728
 * 
 *         global __nvmlDeviceGetMinorNumber
 *         __nvmlDeviceGetMinorNumber = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMinorNumber')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetMinorNumber == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMinorNumber = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetMinorNumber);

                /* "cuda/bindings/_internal/_nvml.pyx":729
 *         global __nvmlDeviceGetMinorNumber
 *         __nvmlDeviceGetMinorNumber = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMinorNumber')
 *         if __nvmlDeviceGetMinorNumber == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMinorNumber == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":730
 *         __nvmlDeviceGetMinorNumber = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMinorNumber')
 *         if __nvmlDeviceGetMinorNumber == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMinorNumber = dlsym(handle, 'nvmlDeviceGetMinorNumber')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":731
 *         if __nvmlDeviceGetMinorNumber == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetMinorNumber = dlsym(handle, 'nvmlDeviceGetMinorNumber')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 731, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":730
 *         __nvmlDeviceGetMinorNumber = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMinorNumber')
 *         if __nvmlDeviceGetMinorNumber == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMinorNumber = dlsym(handle, 'nvmlDeviceGetMinorNumber')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":732
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetMinorNumber = dlsym(handle, 'nvmlDeviceGetMinorNumber')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetBoardPartNumber
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMinorNumber = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetMinorNumber);

                  /* "cuda/bindings/_internal/_nvml.pyx":729
 *         global __nvmlDeviceGetMinorNumber
 *         __nvmlDeviceGetMinorNumber = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMinorNumber')
 *         if __nvmlDeviceGetMinorNumber == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":735
 * 
 *         global __nvmlDeviceGetBoardPartNumber
 *         __nvmlDeviceGetBoardPartNumber = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBoardPartNumber')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetBoardPartNumber == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBoardPartNumber = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetBoardPartNumber);

                /* "cuda/bindings/_internal/_nvml.pyx":736
 *         global __nvmlDeviceGetBoardPartNumber
 *         __nvmlDeviceGetBoardPartNumber = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBoardPartNumber')
 *         if __nvmlDeviceGetBoardPartNumber == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBoardPartNumber == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":737
 *         __nvmlDeviceGetBoardPartNumber = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBoardPartNumber')
 *         if __nvmlDeviceGetBoardPartNumber == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetBoardPartNumber = dlsym(handle, 'nvmlDeviceGetBoardPartNumber')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":738
 *         if __nvmlDeviceGetBoardPartNumber == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetBoardPartNumber = dlsym(handle, 'nvmlDeviceGetBoardPartNumber')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 738, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":737
 *         __nvmlDeviceGetBoardPartNumber = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBoardPartNumber')
 *         if __nvmlDeviceGetBoardPartNumber == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetBoardPartNumber = dlsym(handle, 'nvmlDeviceGetBoardPartNumber')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":739
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetBoardPartNumber = dlsym(handle, 'nvmlDeviceGetBoardPartNumber')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetInforomVersion
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBoardPartNumber = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetBoardPartNumber);

                  /* "cuda/bindings/_internal/_nvml.pyx":736
 *         global __nvmlDeviceGetBoardPartNumber
 *         __nvmlDeviceGetBoardPartNumber = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBoardPartNumber')
 *         if __nvmlDeviceGetBoardPartNumber == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":742
 * 
 *         global __nvmlDeviceGetInforomVersion
 *         __nvmlDeviceGetInforomVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetInforomVersion')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetInforomVersion == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetInforomVersion = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetInforomVersion);

                /* "cuda/bindings/_internal/_nvml.pyx":743
 *         global __nvmlDeviceGetInforomVersion
 *         __nvmlDeviceGetInforomVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetInforomVersion')
 *         if __nvmlDeviceGetInforomVersion == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetInforomVersion == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":744
 *         __nvmlDeviceGetInforomVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetInforomVersion')
 *         if __nvmlDeviceGetInforomVersion == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetInforomVersion = dlsym(handle, 'nvmlDeviceGetInforomVersion')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":745
 *         if __nvmlDeviceGetInforomVersion == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetInforomVersion = dlsym(handle, 'nvmlDeviceGetInforomVersion')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 745, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":744
 *         __nvmlDeviceGetInforomVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetInforomVersion')
 *         if __nvmlDeviceGetInforomVersion == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetInforomVersion = dlsym(handle, 'nvmlDeviceGetInforomVersion')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":746
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetInforomVersion = dlsym(handle, 'nvmlDeviceGetInforomVersion')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetInforomImageVersion
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetInforomVersion = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetInforomVersion);

                  /* "cuda/bindings/_internal/_nvml.pyx":743
 *         global __nvmlDeviceGetInforomVersion
 *         __nvmlDeviceGetInforomVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetInforomVersion')
 *         if __nvmlDeviceGetInforomVersion == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":749
 * 
 *         global __nvmlDeviceGetInforomImageVersion
 *         __nvmlDeviceGetInforomImageVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetInforomImageVersion')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetInforomImageVersion == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetInforomImageVersion = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetInforomImageVersion);

                /* "cuda/bindings/_internal/_nvml.pyx":750
 *         global __nvmlDeviceGetInforomImageVersion
 *         __nvmlDeviceGetInforomImageVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetInforomImageVersion')
 *         if __nvmlDeviceGetInforomImageVersion == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetInforomImageVersion == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":751
 *         __nvmlDeviceGetInforomImageVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetInforomImageVersion')
 *         if __nvmlDeviceGetInforomImageVersion == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetInforomImageVersion = dlsym(handle, 'nvmlDeviceGetInforomImageVersion')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":752
 *         if __nvmlDeviceGetInforomImageVersion == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetInforomImageVersion = dlsym(handle, 'nvmlDeviceGetInforomImageVersion')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 752, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":751
 *         __nvmlDeviceGetInforomImageVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetInforomImageVersion')
 *         if __nvmlDeviceGetInforomImageVersion == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetInforomImageVersion = dlsym(handle, 'nvmlDeviceGetInforomImageVersion')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":753
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetInforomImageVersion = dlsym(handle, 'nvmlDeviceGetInforomImageVersion')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetInforomConfigurationChecksum
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetInforomImageVersion = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetInforomImageVersion);

                  /* "cuda/bindings/_internal/_nvml.pyx":750
 *         global __nvmlDeviceGetInforomImageVersion
 *         __nvmlDeviceGetInforomImageVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetInforomImageVersion')
 *         if __nvmlDeviceGetInforomImageVersion == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":756
 * 
 *         global __nvmlDeviceGetInforomConfigurationChecksum
 *         __nvmlDeviceGetInforomConfigurationChecksum = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetInforomConfigurationChecksum')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetInforomConfigurationChecksum == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetInforomConfigurationChecksum = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetInforomConfiguratio);

                /* "cuda/bindings/_internal/_nvml.pyx":757
 *         global __nvmlDeviceGetInforomConfigurationChecksum
 *         __nvmlDeviceGetInforomConfigurationChecksum = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetInforomConfigurationChecksum')
 *         if __nvmlDeviceGetInforomConfigurationChecksum == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetInforomConfigurationChecksum == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":758
 *         __nvmlDeviceGetInforomConfigurationChecksum = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetInforomConfigurationChecksum')
 *         if __nvmlDeviceGetInforomConfigurationChecksum == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetInforomConfigurationChecksum = dlsym(handle, 'nvmlDeviceGetInforomConfigurationChecksum')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":759
 *         if __nvmlDeviceGetInforomConfigurationChecksum == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetInforomConfigurationChecksum = dlsym(handle, 'nvmlDeviceGetInforomConfigurationChecksum')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 759, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":758
 *         __nvmlDeviceGetInforomConfigurationChecksum = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetInforomConfigurationChecksum')
 *         if __nvmlDeviceGetInforomConfigurationChecksum == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetInforomConfigurationChecksum = dlsym(handle, 'nvmlDeviceGetInforomConfigurationChecksum')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":760
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetInforomConfigurationChecksum = dlsym(handle, 'nvmlDeviceGetInforomConfigurationChecksum')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceValidateInforom
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetInforomConfigurationChecksum = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetInforomConfiguratio);

                  /* "cuda/bindings/_internal/_nvml.pyx":757
 *         global __nvmlDeviceGetInforomConfigurationChecksum
 *         __nvmlDeviceGetInforomConfigurationChecksum = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetInforomConfigurationChecksum')
 *         if __nvmlDeviceGetInforomConfigurationChecksum == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":763
 * 
 *         global __nvmlDeviceValidateInforom
 *         __nvmlDeviceValidateInforom = dlsym(RTLD_DEFAULT, 'nvmlDeviceValidateInforom')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceValidateInforom == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceValidateInforom = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceValidateInforom);

                /* "cuda/bindings/_internal/_nvml.pyx":764
 *         global __nvmlDeviceValidateInforom
 *         __nvmlDeviceValidateInforom = dlsym(RTLD_DEFAULT, 'nvmlDeviceValidateInforom')
 *         if __nvmlDeviceValidateInforom == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceValidateInforom == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":765
 *         __nvmlDeviceValidateInforom = dlsym(RTLD_DEFAULT, 'nvmlDeviceValidateInforom')
 *         if __nvmlDeviceValidateInforom == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceValidateInforom = dlsym(handle, 'nvmlDeviceValidateInforom')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":766
 *         if __nvmlDeviceValidateInforom == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceValidateInforom = dlsym(handle, 'nvmlDeviceValidateInforom')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 766, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":765
 *         __nvmlDeviceValidateInforom = dlsym(RTLD_DEFAULT, 'nvmlDeviceValidateInforom')
 *         if __nvmlDeviceValidateInforom == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceValidateInforom = dlsym(handle, 'nvmlDeviceValidateInforom')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":767
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceValidateInforom = dlsym(handle, 'nvmlDeviceValidateInforom')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetLastBBXFlushTime
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceValidateInforom = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceValidateInforom);

                  /* "cuda/bindings/_internal/_nvml.pyx":764
 *         global __nvmlDeviceValidateInforom
 *         __nvmlDeviceValidateInforom = dlsym(RTLD_DEFAULT, 'nvmlDeviceValidateInforom')
 *         if __nvmlDeviceValidateInforom == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":770
 * 
 *         global __nvmlDeviceGetLastBBXFlushTime
 *         __nvmlDeviceGetLastBBXFlushTime = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetLastBBXFlushTime')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetLastBBXFlushTime == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetLastBBXFlushTime = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetLastBBXFlushTime);

                /* "cuda/bindings/_internal/_nvml.pyx":771
 *         global __nvmlDeviceGetLastBBXFlushTime
 *         __nvmlDeviceGetLastBBXFlushTime = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetLastBBXFlushTime')
 *         if __nvmlDeviceGetLastBBXFlushTime == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetLastBBXFlushTime == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":772
 *         __nvmlDeviceGetLastBBXFlushTime = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetLastBBXFlushTime')
 *         if __nvmlDeviceGetLastBBXFlushTime == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetLastBBXFlushTime = dlsym(handle, 'nvmlDeviceGetLastBBXFlushTime')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":773
 *         if __nvmlDeviceGetLastBBXFlushTime == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetLastBBXFlushTime = dlsym(handle, 'nvmlDeviceGetLastBBXFlushTime')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 773, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":772
 *         __nvmlDeviceGetLastBBXFlushTime = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetLastBBXFlushTime')
 *         if __nvmlDeviceGetLastBBXFlushTime == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetLastBBXFlushTime = dlsym(handle, 'nvmlDeviceGetLastBBXFlushTime')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":774
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetLastBBXFlushTime = dlsym(handle, 'nvmlDeviceGetLastBBXFlushTime')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetDisplayMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetLastBBXFlushTime = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetLastBBXFlushTime);

                  /* "cuda/bindings/_internal/_nvml.pyx":771
 *         global __nvmlDeviceGetLastBBXFlushTime
 *         __nvmlDeviceGetLastBBXFlushTime = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetLastBBXFlushTime')
 *         if __nvmlDeviceGetLastBBXFlushTime == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":777
 * 
 *         global __nvmlDeviceGetDisplayMode
 *         __nvmlDeviceGetDisplayMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDisplayMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetDisplayMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDisplayMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetDisplayMode);

                /* "cuda/bindings/_internal/_nvml.pyx":778
 *         global __nvmlDeviceGetDisplayMode
 *         __nvmlDeviceGetDisplayMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDisplayMode')
 *         if __nvmlDeviceGetDisplayMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDisplayMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":779
 *         __nvmlDeviceGetDisplayMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDisplayMode')
 *         if __nvmlDeviceGetDisplayMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetDisplayMode = dlsym(handle, 'nvmlDeviceGetDisplayMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":780
 *         if __nvmlDeviceGetDisplayMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetDisplayMode = dlsym(handle, 'nvmlDeviceGetDisplayMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 780, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":779
 *         __nvmlDeviceGetDisplayMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDisplayMode')
 *         if __nvmlDeviceGetDisplayMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetDisplayMode = dlsym(handle, 'nvmlDeviceGetDisplayMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":781
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetDisplayMode = dlsym(handle, 'nvmlDeviceGetDisplayMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetDisplayActive
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDisplayMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetDisplayMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":778
 *         global __nvmlDeviceGetDisplayMode
 *         __nvmlDeviceGetDisplayMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDisplayMode')
 *         if __nvmlDeviceGetDisplayMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":784
 * 
 *         global __nvmlDeviceGetDisplayActive
 *         __nvmlDeviceGetDisplayActive = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDisplayActive')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetDisplayActive == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDisplayActive = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetDisplayActive);

                /* "cuda/bindings/_internal/_nvml.pyx":785
 *         global __nvmlDeviceGetDisplayActive
 *         __nvmlDeviceGetDisplayActive = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDisplayActive')
 *         if __nvmlDeviceGetDisplayActive == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDisplayActive == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":786
 *         __nvmlDeviceGetDisplayActive = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDisplayActive')
 *         if __nvmlDeviceGetDisplayActive == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetDisplayActive = dlsym(handle, 'nvmlDeviceGetDisplayActive')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":787
 *         if __nvmlDeviceGetDisplayActive == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetDisplayActive = dlsym(handle, 'nvmlDeviceGetDisplayActive')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 787, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":786
 *         __nvmlDeviceGetDisplayActive = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDisplayActive')
 *         if __nvmlDeviceGetDisplayActive == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetDisplayActive = dlsym(handle, 'nvmlDeviceGetDisplayActive')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":788
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetDisplayActive = dlsym(handle, 'nvmlDeviceGetDisplayActive')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetPersistenceMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDisplayActive = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetDisplayActive);

                  /* "cuda/bindings/_internal/_nvml.pyx":785
 *         global __nvmlDeviceGetDisplayActive
 *         __nvmlDeviceGetDisplayActive = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDisplayActive')
 *         if __nvmlDeviceGetDisplayActive == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":791
 * 
 *         global __nvmlDeviceGetPersistenceMode
 *         __nvmlDeviceGetPersistenceMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPersistenceMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetPersistenceMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPersistenceMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetPersistenceMode);

                /* "cuda/bindings/_internal/_nvml.pyx":792
 *         global __nvmlDeviceGetPersistenceMode
 *         __nvmlDeviceGetPersistenceMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPersistenceMode')
 *         if __nvmlDeviceGetPersistenceMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPersistenceMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":793
 *         __nvmlDeviceGetPersistenceMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPersistenceMode')
 *         if __nvmlDeviceGetPersistenceMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPersistenceMode = dlsym(handle, 'nvmlDeviceGetPersistenceMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":794
 *         if __nvmlDeviceGetPersistenceMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetPersistenceMode = dlsym(handle, 'nvmlDeviceGetPersistenceMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 794, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":793
 *         __nvmlDeviceGetPersistenceMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPersistenceMode')
 *         if __nvmlDeviceGetPersistenceMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPersistenceMode = dlsym(handle, 'nvmlDeviceGetPersistenceMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":795
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetPersistenceMode = dlsym(handle, 'nvmlDeviceGetPersistenceMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetPciInfoExt
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPersistenceMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetPersistenceMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":792
 *         global __nvmlDeviceGetPersistenceMode
 *         __nvmlDeviceGetPersistenceMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPersistenceMode')
 *         if __nvmlDeviceGetPersistenceMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":798
 * 
 *         global __nvmlDeviceGetPciInfoExt
 *         __nvmlDeviceGetPciInfoExt = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPciInfoExt')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetPciInfoExt == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPciInfoExt = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetPciInfoExt);

                /* "cuda/bindings/_internal/_nvml.pyx":799
 *         global __nvmlDeviceGetPciInfoExt
 *         __nvmlDeviceGetPciInfoExt = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPciInfoExt')
 *         if __nvmlDeviceGetPciInfoExt == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPciInfoExt == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":800
 *         __nvmlDeviceGetPciInfoExt = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPciInfoExt')
 *         if __nvmlDeviceGetPciInfoExt == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPciInfoExt = dlsym(handle, 'nvmlDeviceGetPciInfoExt')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":801
 *         if __nvmlDeviceGetPciInfoExt == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetPciInfoExt = dlsym(handle, 'nvmlDeviceGetPciInfoExt')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 801, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":800
 *         __nvmlDeviceGetPciInfoExt = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPciInfoExt')
 *         if __nvmlDeviceGetPciInfoExt == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPciInfoExt = dlsym(handle, 'nvmlDeviceGetPciInfoExt')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":802
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetPciInfoExt = dlsym(handle, 'nvmlDeviceGetPciInfoExt')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetPciInfo_v3
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPciInfoExt = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetPciInfoExt);

                  /* "cuda/bindings/_internal/_nvml.pyx":799
 *         global __nvmlDeviceGetPciInfoExt
 *         __nvmlDeviceGetPciInfoExt = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPciInfoExt')
 *         if __nvmlDeviceGetPciInfoExt == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":805
 * 
 *         global __nvmlDeviceGetPciInfo_v3
 *         __nvmlDeviceGetPciInfo_v3 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPciInfo_v3')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetPciInfo_v3 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPciInfo_v3 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetPciInfo_v3);

                /* "cuda/bindings/_internal/_nvml.pyx":806
 *         global __nvmlDeviceGetPciInfo_v3
 *         __nvmlDeviceGetPciInfo_v3 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPciInfo_v3')
 *         if __nvmlDeviceGetPciInfo_v3 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPciInfo_v3 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":807
 *         __nvmlDeviceGetPciInfo_v3 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPciInfo_v3')
 *         if __nvmlDeviceGetPciInfo_v3 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPciInfo_v3 = dlsym(handle, 'nvmlDeviceGetPciInfo_v3')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":808
 *         if __nvmlDeviceGetPciInfo_v3 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetPciInfo_v3 = dlsym(handle, 'nvmlDeviceGetPciInfo_v3')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 808, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":807
 *         __nvmlDeviceGetPciInfo_v3 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPciInfo_v3')
 *         if __nvmlDeviceGetPciInfo_v3 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPciInfo_v3 = dlsym(handle, 'nvmlDeviceGetPciInfo_v3')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":809
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetPciInfo_v3 = dlsym(handle, 'nvmlDeviceGetPciInfo_v3')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetMaxPcieLinkGeneration
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPciInfo_v3 = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetPciInfo_v3);

                  /* "cuda/bindings/_internal/_nvml.pyx":806
 *         global __nvmlDeviceGetPciInfo_v3
 *         __nvmlDeviceGetPciInfo_v3 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPciInfo_v3')
 *         if __nvmlDeviceGetPciInfo_v3 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":812
 * 
 *         global __nvmlDeviceGetMaxPcieLinkGeneration
 *         __nvmlDeviceGetMaxPcieLinkGeneration = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxPcieLinkGeneration')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetMaxPcieLinkGeneration == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxPcieLinkGeneration = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetMaxPcieLinkGenerati);

                /* "cuda/bindings/_internal/_nvml.pyx":813
 *         global __nvmlDeviceGetMaxPcieLinkGeneration
 *         __nvmlDeviceGetMaxPcieLinkGeneration = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxPcieLinkGeneration')
 *         if __nvmlDeviceGetMaxPcieLinkGeneration == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxPcieLinkGeneration == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":814
 *         __nvmlDeviceGetMaxPcieLinkGeneration = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxPcieLinkGeneration')
 *         if __nvmlDeviceGetMaxPcieLinkGeneration == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMaxPcieLinkGeneration = dlsym(handle, 'nvmlDeviceGetMaxPcieLinkGeneration')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":815
 *         if __nvmlDeviceGetMaxPcieLinkGeneration == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetMaxPcieLinkGeneration = dlsym(handle, 'nvmlDeviceGetMaxPcieLinkGeneration')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 815, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":814
 *         __nvmlDeviceGetMaxPcieLinkGeneration = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxPcieLinkGeneration')
 *         if __nvmlDeviceGetMaxPcieLinkGeneration == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMaxPcieLinkGeneration = dlsym(handle, 'nvmlDeviceGetMaxPcieLinkGeneration')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":816
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetMaxPcieLinkGeneration = dlsym(handle, 'nvmlDeviceGetMaxPcieLinkGeneration')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetGpuMaxPcieLinkGeneration
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxPcieLinkGeneration = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetMaxPcieLinkGenerati);

                  /* "cuda/bindings/_internal/_nvml.pyx":813
 *         global __nvmlDeviceGetMaxPcieLinkGeneration
 *         __nvmlDeviceGetMaxPcieLinkGeneration = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxPcieLinkGeneration')
 *         if __nvmlDeviceGetMaxPcieLinkGeneration == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":819
 * 
 *         global __nvmlDeviceGetGpuMaxPcieLinkGeneration
 *         __nvmlDeviceGetGpuMaxPcieLinkGeneration = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuMaxPcieLinkGeneration')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetGpuMaxPcieLinkGeneration == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuMaxPcieLinkGeneration = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetGpuMaxPcieLinkGener);

                /* "cuda/bindings/_internal/_nvml.pyx":820
 *         global __nvmlDeviceGetGpuMaxPcieLinkGeneration
 *         __nvmlDeviceGetGpuMaxPcieLinkGeneration = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuMaxPcieLinkGeneration')
 *         if __nvmlDeviceGetGpuMaxPcieLinkGeneration == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuMaxPcieLinkGeneration == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":821
 *         __nvmlDeviceGetGpuMaxPcieLinkGeneration = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuMaxPcieLinkGeneration')
 *         if __nvmlDeviceGetGpuMaxPcieLinkGeneration == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuMaxPcieLinkGeneration = dlsym(handle, 'nvmlDeviceGetGpuMaxPcieLinkGeneration')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":822
 *         if __nvmlDeviceGetGpuMaxPcieLinkGeneration == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetGpuMaxPcieLinkGeneration = dlsym(handle, 'nvmlDeviceGetGpuMaxPcieLinkGeneration')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 822, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":821
 *         __nvmlDeviceGetGpuMaxPcieLinkGeneration = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuMaxPcieLinkGeneration')
 *         if __nvmlDeviceGetGpuMaxPcieLinkGeneration == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuMaxPcieLinkGeneration = dlsym(handle, 'nvmlDeviceGetGpuMaxPcieLinkGeneration')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":823
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuMaxPcieLinkGeneration = dlsym(handle, 'nvmlDeviceGetGpuMaxPcieLinkGeneration')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetMaxPcieLinkWidth
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuMaxPcieLinkGeneration = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetGpuMaxPcieLinkGener);

                  /* "cuda/bindings/_internal/_nvml.pyx":820
 *         global __nvmlDeviceGetGpuMaxPcieLinkGeneration
 *         __nvmlDeviceGetGpuMaxPcieLinkGeneration = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuMaxPcieLinkGeneration')
 *         if __nvmlDeviceGetGpuMaxPcieLinkGeneration == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":826
 * 
 *         global __nvmlDeviceGetMaxPcieLinkWidth
 *         __nvmlDeviceGetMaxPcieLinkWidth = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxPcieLinkWidth')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetMaxPcieLinkWidth == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxPcieLinkWidth = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetMaxPcieLinkWidth);

                /* "cuda/bindings/_internal/_nvml.pyx":827
 *         global __nvmlDeviceGetMaxPcieLinkWidth
 *         __nvmlDeviceGetMaxPcieLinkWidth = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxPcieLinkWidth')
 *         if __nvmlDeviceGetMaxPcieLinkWidth == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxPcieLinkWidth == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":828
 *         __nvmlDeviceGetMaxPcieLinkWidth = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxPcieLinkWidth')
 *         if __nvmlDeviceGetMaxPcieLinkWidth == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMaxPcieLinkWidth = dlsym(handle, 'nvmlDeviceGetMaxPcieLinkWidth')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":829
 *         if __nvmlDeviceGetMaxPcieLinkWidth == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetMaxPcieLinkWidth = dlsym(handle, 'nvmlDeviceGetMaxPcieLinkWidth')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 829, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":828
 *         __nvmlDeviceGetMaxPcieLinkWidth = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxPcieLinkWidth')
 *         if __nvmlDeviceGetMaxPcieLinkWidth == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMaxPcieLinkWidth = dlsym(handle, 'nvmlDeviceGetMaxPcieLinkWidth')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":830
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetMaxPcieLinkWidth = dlsym(handle, 'nvmlDeviceGetMaxPcieLinkWidth')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetCurrPcieLinkGeneration
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxPcieLinkWidth = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetMaxPcieLinkWidth);

                  /* "cuda/bindings/_internal/_nvml.pyx":827
 *         global __nvmlDeviceGetMaxPcieLinkWidth
 *         __nvmlDeviceGetMaxPcieLinkWidth = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxPcieLinkWidth')
 *         if __nvmlDeviceGetMaxPcieLinkWidth == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":833
 * 
 *         global __nvmlDeviceGetCurrPcieLinkGeneration
 *         __nvmlDeviceGetCurrPcieLinkGeneration = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCurrPcieLinkGeneration')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetCurrPcieLinkGeneration == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrPcieLinkGeneration = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetCurrPcieLinkGenerat);

                /* "cuda/bindings/_internal/_nvml.pyx":834
 *         global __nvmlDeviceGetCurrPcieLinkGeneration
 *         __nvmlDeviceGetCurrPcieLinkGeneration = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCurrPcieLinkGeneration')
 *         if __nvmlDeviceGetCurrPcieLinkGeneration == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrPcieLinkGeneration == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":835
 *         __nvmlDeviceGetCurrPcieLinkGeneration = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCurrPcieLinkGeneration')
 *         if __nvmlDeviceGetCurrPcieLinkGeneration == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetCurrPcieLinkGeneration = dlsym(handle, 'nvmlDeviceGetCurrPcieLinkGeneration')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":836
 *         if __nvmlDeviceGetCurrPcieLinkGeneration == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetCurrPcieLinkGeneration = dlsym(handle, 'nvmlDeviceGetCurrPcieLinkGeneration')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 836, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":835
 *         __nvmlDeviceGetCurrPcieLinkGeneration = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCurrPcieLinkGeneration')
 *         if __nvmlDeviceGetCurrPcieLinkGeneration == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetCurrPcieLinkGeneration = dlsym(handle, 'nvmlDeviceGetCurrPcieLinkGeneration')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":837
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetCurrPcieLinkGeneration = dlsym(handle, 'nvmlDeviceGetCurrPcieLinkGeneration')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetCurrPcieLinkWidth
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrPcieLinkGeneration = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetCurrPcieLinkGenerat);

                  /* "cuda/bindings/_internal/_nvml.pyx":834
 *         global __nvmlDeviceGetCurrPcieLinkGeneration
 *         __nvmlDeviceGetCurrPcieLinkGeneration = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCurrPcieLinkGeneration')
 *         if __nvmlDeviceGetCurrPcieLinkGeneration == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":840
 * 
 *         global __nvmlDeviceGetCurrPcieLinkWidth
 *         __nvmlDeviceGetCurrPcieLinkWidth = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCurrPcieLinkWidth')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetCurrPcieLinkWidth == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrPcieLinkWidth = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetCurrPcieLinkWidth);

                /* "cuda/bindings/_internal/_nvml.pyx":841
 *         global __nvmlDeviceGetCurrPcieLinkWidth
 *         __nvmlDeviceGetCurrPcieLinkWidth = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCurrPcieLinkWidth')
 *         if __nvmlDeviceGetCurrPcieLinkWidth == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrPcieLinkWidth == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":842
 *         __nvmlDeviceGetCurrPcieLinkWidth = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCurrPcieLinkWidth')
 *         if __nvmlDeviceGetCurrPcieLinkWidth == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetCurrPcieLinkWidth = dlsym(handle, 'nvmlDeviceGetCurrPcieLinkWidth')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":843
 *         if __nvmlDeviceGetCurrPcieLinkWidth == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetCurrPcieLinkWidth = dlsym(handle, 'nvmlDeviceGetCurrPcieLinkWidth')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 843, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":842
 *         __nvmlDeviceGetCurrPcieLinkWidth = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCurrPcieLinkWidth')
 *         if __nvmlDeviceGetCurrPcieLinkWidth == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetCurrPcieLinkWidth = dlsym(handle, 'nvmlDeviceGetCurrPcieLinkWidth')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":844
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetCurrPcieLinkWidth = dlsym(handle, 'nvmlDeviceGetCurrPcieLinkWidth')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetPcieThroughput
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrPcieLinkWidth = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetCurrPcieLinkWidth);

                  /* "cuda/bindings/_internal/_nvml.pyx":841
 *         global __nvmlDeviceGetCurrPcieLinkWidth
 *         __nvmlDeviceGetCurrPcieLinkWidth = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCurrPcieLinkWidth')
 *         if __nvmlDeviceGetCurrPcieLinkWidth == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":847
 * 
 *         global __nvmlDeviceGetPcieThroughput
 *         __nvmlDeviceGetPcieThroughput = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPcieThroughput')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetPcieThroughput == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieThroughput = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetPcieThroughput);

                /* "cuda/bindings/_internal/_nvml.pyx":848
 *         global __nvmlDeviceGetPcieThroughput
 *         __nvmlDeviceGetPcieThroughput = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPcieThroughput')
 *         if __nvmlDeviceGetPcieThroughput == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieThroughput == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":849
 *         __nvmlDeviceGetPcieThroughput = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPcieThroughput')
 *         if __nvmlDeviceGetPcieThroughput == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPcieThroughput = dlsym(handle, 'nvmlDeviceGetPcieThroughput')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":850
 *         if __nvmlDeviceGetPcieThroughput == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetPcieThroughput = dlsym(handle, 'nvmlDeviceGetPcieThroughput')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 850, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":849
 *         __nvmlDeviceGetPcieThroughput = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPcieThroughput')
 *         if __nvmlDeviceGetPcieThroughput == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPcieThroughput = dlsym(handle, 'nvmlDeviceGetPcieThroughput')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":851
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetPcieThroughput = dlsym(handle, 'nvmlDeviceGetPcieThroughput')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetPcieReplayCounter
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieThroughput = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetPcieThroughput);

                  /* "cuda/bindings/_internal/_nvml.pyx":848
 *         global __nvmlDeviceGetPcieThroughput
 *         __nvmlDeviceGetPcieThroughput = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPcieThroughput')
 *         if __nvmlDeviceGetPcieThroughput == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":854
 * 
 *         global __nvmlDeviceGetPcieReplayCounter
 *         __nvmlDeviceGetPcieReplayCounter = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPcieReplayCounter')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetPcieReplayCounter == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieReplayCounter = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetPcieReplayCounter);

                /* "cuda/bindings/_internal/_nvml.pyx":855
 *         global __nvmlDeviceGetPcieReplayCounter
 *         __nvmlDeviceGetPcieReplayCounter = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPcieReplayCounter')
 *         if __nvmlDeviceGetPcieReplayCounter == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieReplayCounter == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":856
 *         __nvmlDeviceGetPcieReplayCounter = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPcieReplayCounter')
 *         if __nvmlDeviceGetPcieReplayCounter == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPcieReplayCounter = dlsym(handle, 'nvmlDeviceGetPcieReplayCounter')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":857
 *         if __nvmlDeviceGetPcieReplayCounter == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetPcieReplayCounter = dlsym(handle, 'nvmlDeviceGetPcieReplayCounter')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 857, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":856
 *         __nvmlDeviceGetPcieReplayCounter = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPcieReplayCounter')
 *         if __nvmlDeviceGetPcieReplayCounter == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPcieReplayCounter = dlsym(handle, 'nvmlDeviceGetPcieReplayCounter')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":858
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetPcieReplayCounter = dlsym(handle, 'nvmlDeviceGetPcieReplayCounter')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetClockInfo
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieReplayCounter = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetPcieReplayCounter);

                  /* "cuda/bindings/_internal/_nvml.pyx":855
 *         global __nvmlDeviceGetPcieReplayCounter
 *         __nvmlDeviceGetPcieReplayCounter = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPcieReplayCounter')
 *         if __nvmlDeviceGetPcieReplayCounter == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":861
 * 
 *         global __nvmlDeviceGetClockInfo
 *         __nvmlDeviceGetClockInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetClockInfo')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetClockInfo == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClockInfo = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetClockInfo);

                /* "cuda/bindings/_internal/_nvml.pyx":862
 *         global __nvmlDeviceGetClockInfo
 *         __nvmlDeviceGetClockInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetClockInfo')
 *         if __nvmlDeviceGetClockInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClockInfo == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":863
 *         __nvmlDeviceGetClockInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetClockInfo')
 *         if __nvmlDeviceGetClockInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetClockInfo = dlsym(handle, 'nvmlDeviceGetClockInfo')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":864
 *         if __nvmlDeviceGetClockInfo == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetClockInfo = dlsym(handle, 'nvmlDeviceGetClockInfo')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 864, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":863
 *         __nvmlDeviceGetClockInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetClockInfo')
 *         if __nvmlDeviceGetClockInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetClockInfo = dlsym(handle, 'nvmlDeviceGetClockInfo')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":865
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetClockInfo = dlsym(handle, 'nvmlDeviceGetClockInfo')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetMaxClockInfo
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClockInfo = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetClockInfo);

                  /* "cuda/bindings/_internal/_nvml.pyx":862
 *         global __nvmlDeviceGetClockInfo
 *         __nvmlDeviceGetClockInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetClockInfo')
 *         if __nvmlDeviceGetClockInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":868
 * 
 *         global __nvmlDeviceGetMaxClockInfo
 *         __nvmlDeviceGetMaxClockInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxClockInfo')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetMaxClockInfo == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxClockInfo = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetMaxClockInfo);

                /* "cuda/bindings/_internal/_nvml.pyx":869
 *         global __nvmlDeviceGetMaxClockInfo
 *         __nvmlDeviceGetMaxClockInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxClockInfo')
 *         if __nvmlDeviceGetMaxClockInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxClockInfo == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":870
 *         __nvmlDeviceGetMaxClockInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxClockInfo')
 *         if __nvmlDeviceGetMaxClockInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMaxClockInfo = dlsym(handle, 'nvmlDeviceGetMaxClockInfo')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":871
 *         if __nvmlDeviceGetMaxClockInfo == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetMaxClockInfo = dlsym(handle, 'nvmlDeviceGetMaxClockInfo')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 871, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":870
 *         __nvmlDeviceGetMaxClockInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxClockInfo')
 *         if __nvmlDeviceGetMaxClockInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMaxClockInfo = dlsym(handle, 'nvmlDeviceGetMaxClockInfo')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":872
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetMaxClockInfo = dlsym(handle, 'nvmlDeviceGetMaxClockInfo')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetGpcClkVfOffset
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxClockInfo = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetMaxClockInfo);

                  /* "cuda/bindings/_internal/_nvml.pyx":869
 *         global __nvmlDeviceGetMaxClockInfo
 *         __nvmlDeviceGetMaxClockInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxClockInfo')
 *         if __nvmlDeviceGetMaxClockInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":875
 * 
 *         global __nvmlDeviceGetGpcClkVfOffset
 *         __nvmlDeviceGetGpcClkVfOffset = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpcClkVfOffset')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetGpcClkVfOffset == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpcClkVfOffset = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetGpcClkVfOffset);

                /* "cuda/bindings/_internal/_nvml.pyx":876
 *         global __nvmlDeviceGetGpcClkVfOffset
 *         __nvmlDeviceGetGpcClkVfOffset = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpcClkVfOffset')
 *         if __nvmlDeviceGetGpcClkVfOffset == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpcClkVfOffset == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":877
 *         __nvmlDeviceGetGpcClkVfOffset = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpcClkVfOffset')
 *         if __nvmlDeviceGetGpcClkVfOffset == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGpcClkVfOffset = dlsym(handle, 'nvmlDeviceGetGpcClkVfOffset')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":878
 *         if __nvmlDeviceGetGpcClkVfOffset == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetGpcClkVfOffset = dlsym(handle, 'nvmlDeviceGetGpcClkVfOffset')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 878, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":877
 *         __nvmlDeviceGetGpcClkVfOffset = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpcClkVfOffset')
 *         if __nvmlDeviceGetGpcClkVfOffset == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGpcClkVfOffset = dlsym(handle, 'nvmlDeviceGetGpcClkVfOffset')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":879
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetGpcClkVfOffset = dlsym(handle, 'nvmlDeviceGetGpcClkVfOffset')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetClock
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpcClkVfOffset = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetGpcClkVfOffset);

                  /* "cuda/bindings/_internal/_nvml.pyx":876
 *         global __nvmlDeviceGetGpcClkVfOffset
 *         __nvmlDeviceGetGpcClkVfOffset = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpcClkVfOffset')
 *         if __nvmlDeviceGetGpcClkVfOffset == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":882
 * 
 *         global __nvmlDeviceGetClock
 *         __nvmlDeviceGetClock = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetClock')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetClock == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClock = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetClock);

                /* "cuda/bindings/_internal/_nvml.pyx":883
 *         global __nvmlDeviceGetClock
 *         __nvmlDeviceGetClock = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetClock')
 *         if __nvmlDeviceGetClock == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClock == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":884
 *         __nvmlDeviceGetClock = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetClock')
 *         if __nvmlDeviceGetClock == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetClock = dlsym(handle, 'nvmlDeviceGetClock')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":885
 *         if __nvmlDeviceGetClock == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetClock = dlsym(handle, 'nvmlDeviceGetClock')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 885, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":884
 *         __nvmlDeviceGetClock = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetClock')
 *         if __nvmlDeviceGetClock == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetClock = dlsym(handle, 'nvmlDeviceGetClock')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":886
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetClock = dlsym(handle, 'nvmlDeviceGetClock')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetMaxCustomerBoostClock
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClock = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetClock);

                  /* "cuda/bindings/_internal/_nvml.pyx":883
 *         global __nvmlDeviceGetClock
 *         __nvmlDeviceGetClock = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetClock')
 *         if __nvmlDeviceGetClock == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":889
 * 
 *         global __nvmlDeviceGetMaxCustomerBoostClock
 *         __nvmlDeviceGetMaxCustomerBoostClock = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxCustomerBoostClock')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetMaxCustomerBoostClock == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxCustomerBoostClock = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetMaxCustomerBoostClo);

                /* "cuda/bindings/_internal/_nvml.pyx":890
 *         global __nvmlDeviceGetMaxCustomerBoostClock
 *         __nvmlDeviceGetMaxCustomerBoostClock = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxCustomerBoostClock')
 *         if __nvmlDeviceGetMaxCustomerBoostClock == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxCustomerBoostClock == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":891
 *         __nvmlDeviceGetMaxCustomerBoostClock = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxCustomerBoostClock')
 *         if __nvmlDeviceGetMaxCustomerBoostClock == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMaxCustomerBoostClock = dlsym(handle, 'nvmlDeviceGetMaxCustomerBoostClock')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":892
 *         if __nvmlDeviceGetMaxCustomerBoostClock == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetMaxCustomerBoostClock = dlsym(handle, 'nvmlDeviceGetMaxCustomerBoostClock')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 892, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":891
 *         __nvmlDeviceGetMaxCustomerBoostClock = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxCustomerBoostClock')
 *         if __nvmlDeviceGetMaxCustomerBoostClock == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMaxCustomerBoostClock = dlsym(handle, 'nvmlDeviceGetMaxCustomerBoostClock')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":893
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetMaxCustomerBoostClock = dlsym(handle, 'nvmlDeviceGetMaxCustomerBoostClock')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetSupportedMemoryClocks
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxCustomerBoostClock = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetMaxCustomerBoostClo);

                  /* "cuda/bindings/_internal/_nvml.pyx":890
 *         global __nvmlDeviceGetMaxCustomerBoostClock
 *         __nvmlDeviceGetMaxCustomerBoostClock = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxCustomerBoostClock')
 *         if __nvmlDeviceGetMaxCustomerBoostClock == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":896
 * 
 *         global __nvmlDeviceGetSupportedMemoryClocks
 *         __nvmlDeviceGetSupportedMemoryClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedMemoryClocks')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetSupportedMemoryClocks == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedMemoryClocks = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetSupportedMemoryCloc);

                /* "cuda/bindings/_internal/_nvml.pyx":897
 *         global __nvmlDeviceGetSupportedMemoryClocks
 *         __nvmlDeviceGetSupportedMemoryClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedMemoryClocks')
 *         if __nvmlDeviceGetSupportedMemoryClocks == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedMemoryClocks == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":898
 *         __nvmlDeviceGetSupportedMemoryClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedMemoryClocks')
 *         if __nvmlDeviceGetSupportedMemoryClocks == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetSupportedMemoryClocks = dlsym(handle, 'nvmlDeviceGetSupportedMemoryClocks')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":899
 *         if __nvmlDeviceGetSupportedMemoryClocks == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetSupportedMemoryClocks = dlsym(handle, 'nvmlDeviceGetSupportedMemoryClocks')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 899, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":898
 *         __nvmlDeviceGetSupportedMemoryClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedMemoryClocks')
 *         if __nvmlDeviceGetSupportedMemoryClocks == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetSupportedMemoryClocks = dlsym(handle, 'nvmlDeviceGetSupportedMemoryClocks')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":900
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetSupportedMemoryClocks = dlsym(handle, 'nvmlDeviceGetSupportedMemoryClocks')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetSupportedGraphicsClocks
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedMemoryClocks = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetSupportedMemoryCloc);

                  /* "cuda/bindings/_internal/_nvml.pyx":897
 *         global __nvmlDeviceGetSupportedMemoryClocks
 *         __nvmlDeviceGetSupportedMemoryClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedMemoryClocks')
 *         if __nvmlDeviceGetSupportedMemoryClocks == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":903
 * 
 *         global __nvmlDeviceGetSupportedGraphicsClocks
 *         __nvmlDeviceGetSupportedGraphicsClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedGraphicsClocks')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetSupportedGraphicsClocks == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedGraphicsClocks = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetSupportedGraphicsCl);

                /* "cuda/bindings/_internal/_nvml.pyx":904
 *         global __nvmlDeviceGetSupportedGraphicsClocks
 *         __nvmlDeviceGetSupportedGraphicsClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedGraphicsClocks')
 *         if __nvmlDeviceGetSupportedGraphicsClocks == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedGraphicsClocks == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":905
 *         __nvmlDeviceGetSupportedGraphicsClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedGraphicsClocks')
 *         if __nvmlDeviceGetSupportedGraphicsClocks == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetSupportedGraphicsClocks = dlsym(handle, 'nvmlDeviceGetSupportedGraphicsClocks')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":906
 *         if __nvmlDeviceGetSupportedGraphicsClocks == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetSupportedGraphicsClocks = dlsym(handle, 'nvmlDeviceGetSupportedGraphicsClocks')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 906, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":905
 *         __nvmlDeviceGetSupportedGraphicsClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedGraphicsClocks')
 *         if __nvmlDeviceGetSupportedGraphicsClocks == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetSupportedGraphicsClocks = dlsym(handle, 'nvmlDeviceGetSupportedGraphicsClocks')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":907
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetSupportedGraphicsClocks = dlsym(handle, 'nvmlDeviceGetSupportedGraphicsClocks')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetAutoBoostedClocksEnabled
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedGraphicsClocks = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetSupportedGraphicsCl);

                  /* "cuda/bindings/_internal/_nvml.pyx":904
 *         global __nvmlDeviceGetSupportedGraphicsClocks
 *         __nvmlDeviceGetSupportedGraphicsClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedGraphicsClocks')
 *         if __nvmlDeviceGetSupportedGraphicsClocks == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":910
 * 
 *         global __nvmlDeviceGetAutoBoostedClocksEnabled
 *         __nvmlDeviceGetAutoBoostedClocksEnabled = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAutoBoostedClocksEnabled')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetAutoBoostedClocksEnabled == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAutoBoostedClocksEnabled = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetAutoBoostedClocksEn);

                /* "cuda/bindings/_internal/_nvml.pyx":911
 *         global __nvmlDeviceGetAutoBoostedClocksEnabled
 *         __nvmlDeviceGetAutoBoostedClocksEnabled = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAutoBoostedClocksEnabled')
 *         if __nvmlDeviceGetAutoBoostedClocksEnabled == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAutoBoostedClocksEnabled == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":912
 *         __nvmlDeviceGetAutoBoostedClocksEnabled = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAutoBoostedClocksEnabled')
 *         if __nvmlDeviceGetAutoBoostedClocksEnabled == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetAutoBoostedClocksEnabled = dlsym(handle, 'nvmlDeviceGetAutoBoostedClocksEnabled')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":913
 *         if __nvmlDeviceGetAutoBoostedClocksEnabled == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetAutoBoostedClocksEnabled = dlsym(handle, 'nvmlDeviceGetAutoBoostedClocksEnabled')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 913, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":912
 *         __nvmlDeviceGetAutoBoostedClocksEnabled = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAutoBoostedClocksEnabled')
 *         if __nvmlDeviceGetAutoBoostedClocksEnabled == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetAutoBoostedClocksEnabled = dlsym(handle, 'nvmlDeviceGetAutoBoostedClocksEnabled')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":914
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetAutoBoostedClocksEnabled = dlsym(handle, 'nvmlDeviceGetAutoBoostedClocksEnabled')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetFanSpeed
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAutoBoostedClocksEnabled = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetAutoBoostedClocksEn);

                  /* "cuda/bindings/_internal/_nvml.pyx":911
 *         global __nvmlDeviceGetAutoBoostedClocksEnabled
 *         __nvmlDeviceGetAutoBoostedClocksEnabled = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAutoBoostedClocksEnabled')
 *         if __nvmlDeviceGetAutoBoostedClocksEnabled == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":917
 * 
 *         global __nvmlDeviceGetFanSpeed
 *         __nvmlDeviceGetFanSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFanSpeed')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetFanSpeed == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanSpeed = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetFanSpeed);

                /* "cuda/bindings/_internal/_nvml.pyx":918
 *         global __nvmlDeviceGetFanSpeed
 *         __nvmlDeviceGetFanSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFanSpeed')
 *         if __nvmlDeviceGetFanSpeed == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanSpeed == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":919
 *         __nvmlDeviceGetFanSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFanSpeed')
 *         if __nvmlDeviceGetFanSpeed == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetFanSpeed = dlsym(handle, 'nvmlDeviceGetFanSpeed')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":920
 *         if __nvmlDeviceGetFanSpeed == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetFanSpeed = dlsym(handle, 'nvmlDeviceGetFanSpeed')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 920, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":919
 *         __nvmlDeviceGetFanSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFanSpeed')
 *         if __nvmlDeviceGetFanSpeed == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetFanSpeed = dlsym(handle, 'nvmlDeviceGetFanSpeed')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":921
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetFanSpeed = dlsym(handle, 'nvmlDeviceGetFanSpeed')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetFanSpeed_v2
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanSpeed = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetFanSpeed);

                  /* "cuda/bindings/_internal/_nvml.pyx":918
 *         global __nvmlDeviceGetFanSpeed
 *         __nvmlDeviceGetFanSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFanSpeed')
 *         if __nvmlDeviceGetFanSpeed == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":924
 * 
 *         global __nvmlDeviceGetFanSpeed_v2
 *         __nvmlDeviceGetFanSpeed_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFanSpeed_v2')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetFanSpeed_v2 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanSpeed_v2 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetFanSpeed_v2);

                /* "cuda/bindings/_internal/_nvml.pyx":925
 *         global __nvmlDeviceGetFanSpeed_v2
 *         __nvmlDeviceGetFanSpeed_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFanSpeed_v2')
 *         if __nvmlDeviceGetFanSpeed_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanSpeed_v2 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":926
 *         __nvmlDeviceGetFanSpeed_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFanSpeed_v2')
 *         if __nvmlDeviceGetFanSpeed_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetFanSpeed_v2 = dlsym(handle, 'nvmlDeviceGetFanSpeed_v2')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":927
 *         if __nvmlDeviceGetFanSpeed_v2 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetFanSpeed_v2 = dlsym(handle, 'nvmlDeviceGetFanSpeed_v2')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 927, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":926
 *         __nvmlDeviceGetFanSpeed_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFanSpeed_v2')
 *         if __nvmlDeviceGetFanSpeed_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetFanSpeed_v2 = dlsym(handle, 'nvmlDeviceGetFanSpeed_v2')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":928
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetFanSpeed_v2 = dlsym(handle, 'nvmlDeviceGetFanSpeed_v2')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetFanSpeedRPM
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanSpeed_v2 = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetFanSpeed_v2);

                  /* "cuda/bindings/_internal/_nvml.pyx":925
 *         global __nvmlDeviceGetFanSpeed_v2
 *         __nvmlDeviceGetFanSpeed_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFanSpeed_v2')
 *         if __nvmlDeviceGetFanSpeed_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":931
 * 
 *         global __nvmlDeviceGetFanSpeedRPM
 *         __nvmlDeviceGetFanSpeedRPM = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFanSpeedRPM')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetFanSpeedRPM == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanSpeedRPM = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetFanSpeedRPM);

                /* "cuda/bindings/_internal/_nvml.pyx":932
 *         global __nvmlDeviceGetFanSpeedRPM
 *         __nvmlDeviceGetFanSpeedRPM = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFanSpeedRPM')
 *         if __nvmlDeviceGetFanSpeedRPM == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanSpeedRPM == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":933
 *         __nvmlDeviceGetFanSpeedRPM = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFanSpeedRPM')
 *         if __nvmlDeviceGetFanSpeedRPM == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetFanSpeedRPM = dlsym(handle, 'nvmlDeviceGetFanSpeedRPM')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":934
 *         if __nvmlDeviceGetFanSpeedRPM == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetFanSpeedRPM = dlsym(handle, 'nvmlDeviceGetFanSpeedRPM')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 934, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":933
 *         __nvmlDeviceGetFanSpeedRPM = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFanSpeedRPM')
 *         if __nvmlDeviceGetFanSpeedRPM == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetFanSpeedRPM = dlsym(handle, 'nvmlDeviceGetFanSpeedRPM')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":935
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetFanSpeedRPM = dlsym(handle, 'nvmlDeviceGetFanSpeedRPM')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetTargetFanSpeed
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanSpeedRPM = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetFanSpeedRPM);

                  /* "cuda/bindings/_internal/_nvml.pyx":932
 *         global __nvmlDeviceGetFanSpeedRPM
 *         __nvmlDeviceGetFanSpeedRPM = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFanSpeedRPM')
 *         if __nvmlDeviceGetFanSpeedRPM == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":938
 * 
 *         global __nvmlDeviceGetTargetFanSpeed
 *         __nvmlDeviceGetTargetFanSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTargetFanSpeed')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetTargetFanSpeed == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTargetFanSpeed = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetTargetFanSpeed);

                /* "cuda/bindings/_internal/_nvml.pyx":939
 *         global __nvmlDeviceGetTargetFanSpeed
 *         __nvmlDeviceGetTargetFanSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTargetFanSpeed')
 *         if __nvmlDeviceGetTargetFanSpeed == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTargetFanSpeed == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":940
 *         __nvmlDeviceGetTargetFanSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTargetFanSpeed')
 *         if __nvmlDeviceGetTargetFanSpeed == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetTargetFanSpeed = dlsym(handle, 'nvmlDeviceGetTargetFanSpeed')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":941
 *         if __nvmlDeviceGetTargetFanSpeed == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetTargetFanSpeed = dlsym(handle, 'nvmlDeviceGetTargetFanSpeed')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 941, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":940
 *         __nvmlDeviceGetTargetFanSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTargetFanSpeed')
 *         if __nvmlDeviceGetTargetFanSpeed == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetTargetFanSpeed = dlsym(handle, 'nvmlDeviceGetTargetFanSpeed')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":942
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetTargetFanSpeed = dlsym(handle, 'nvmlDeviceGetTargetFanSpeed')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetMinMaxFanSpeed
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTargetFanSpeed = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetTargetFanSpeed);

                  /* "cuda/bindings/_internal/_nvml.pyx":939
 *         global __nvmlDeviceGetTargetFanSpeed
 *         __nvmlDeviceGetTargetFanSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTargetFanSpeed')
 *         if __nvmlDeviceGetTargetFanSpeed == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":945
 * 
 *         global __nvmlDeviceGetMinMaxFanSpeed
 *         __nvmlDeviceGetMinMaxFanSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMinMaxFanSpeed')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetMinMaxFanSpeed == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMinMaxFanSpeed = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetMinMaxFanSpeed);

                /* "cuda/bindings/_internal/_nvml.pyx":946
 *         global __nvmlDeviceGetMinMaxFanSpeed
 *         __nvmlDeviceGetMinMaxFanSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMinMaxFanSpeed')
 *         if __nvmlDeviceGetMinMaxFanSpeed == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMinMaxFanSpeed == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":947
 *         __nvmlDeviceGetMinMaxFanSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMinMaxFanSpeed')
 *         if __nvmlDeviceGetMinMaxFanSpeed == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMinMaxFanSpeed = dlsym(handle, 'nvmlDeviceGetMinMaxFanSpeed')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":948
 *         if __nvmlDeviceGetMinMaxFanSpeed == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetMinMaxFanSpeed = dlsym(handle, 'nvmlDeviceGetMinMaxFanSpeed')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 948, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":947
 *         __nvmlDeviceGetMinMaxFanSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMinMaxFanSpeed')
 *         if __nvmlDeviceGetMinMaxFanSpeed == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMinMaxFanSpeed = dlsym(handle, 'nvmlDeviceGetMinMaxFanSpeed')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":949
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetMinMaxFanSpeed = dlsym(handle, 'nvmlDeviceGetMinMaxFanSpeed')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetFanControlPolicy_v2
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMinMaxFanSpeed = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetMinMaxFanSpeed);

                  /* "cuda/bindings/_internal/_nvml.pyx":946
 *         global __nvmlDeviceGetMinMaxFanSpeed
 *         __nvmlDeviceGetMinMaxFanSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMinMaxFanSpeed')
 *         if __nvmlDeviceGetMinMaxFanSpeed == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":952
 * 
 *         global __nvmlDeviceGetFanControlPolicy_v2
 *         __nvmlDeviceGetFanControlPolicy_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFanControlPolicy_v2')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetFanControlPolicy_v2 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanControlPolicy_v2 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetFanControlPolicy_v2);

                /* "cuda/bindings/_internal/_nvml.pyx":953
 *         global __nvmlDeviceGetFanControlPolicy_v2
 *         __nvmlDeviceGetFanControlPolicy_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFanControlPolicy_v2')
 *         if __nvmlDeviceGetFanControlPolicy_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanControlPolicy_v2 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":954
 *         __nvmlDeviceGetFanControlPolicy_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFanControlPolicy_v2')
 *         if __nvmlDeviceGetFanControlPolicy_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetFanControlPolicy_v2 = dlsym(handle, 'nvmlDeviceGetFanControlPolicy_v2')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":955
 *         if __nvmlDeviceGetFanControlPolicy_v2 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetFanControlPolicy_v2 = dlsym(handle, 'nvmlDeviceGetFanControlPolicy_v2')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 955, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":954
 *         __nvmlDeviceGetFanControlPolicy_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFanControlPolicy_v2')
 *         if __nvmlDeviceGetFanControlPolicy_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetFanControlPolicy_v2 = dlsym(handle, 'nvmlDeviceGetFanControlPolicy_v2')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":956
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetFanControlPolicy_v2 = dlsym(handle, 'nvmlDeviceGetFanControlPolicy_v2')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetNumFans
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanControlPolicy_v2 = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetFanControlPolicy_v2);

                  /* "cuda/bindings/_internal/_nvml.pyx":953
 *         global __nvmlDeviceGetFanControlPolicy_v2
 *         __nvmlDeviceGetFanControlPolicy_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFanControlPolicy_v2')
 *         if __nvmlDeviceGetFanControlPolicy_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":959
 * 
 *         global __nvmlDeviceGetNumFans
 *         __nvmlDeviceGetNumFans = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNumFans')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetNumFans == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNumFans = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetNumFans);

                /* "cuda/bindings/_internal/_nvml.pyx":960
 *         global __nvmlDeviceGetNumFans
 *         __nvmlDeviceGetNumFans = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNumFans')
 *         if __nvmlDeviceGetNumFans == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNumFans == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":961
 *         __nvmlDeviceGetNumFans = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNumFans')
 *         if __nvmlDeviceGetNumFans == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetNumFans = dlsym(handle, 'nvmlDeviceGetNumFans')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":962
 *         if __nvmlDeviceGetNumFans == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetNumFans = dlsym(handle, 'nvmlDeviceGetNumFans')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 962, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":961
 *         __nvmlDeviceGetNumFans = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNumFans')
 *         if __nvmlDeviceGetNumFans == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetNumFans = dlsym(handle, 'nvmlDeviceGetNumFans')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":963
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetNumFans = dlsym(handle, 'nvmlDeviceGetNumFans')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetCoolerInfo
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNumFans = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetNumFans);

                  /* "cuda/bindings/_internal/_nvml.pyx":960
 *         global __nvmlDeviceGetNumFans
 *         __nvmlDeviceGetNumFans = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNumFans')
 *         if __nvmlDeviceGetNumFans == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":966
 * 
 *         global __nvmlDeviceGetCoolerInfo
 *         __nvmlDeviceGetCoolerInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCoolerInfo')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetCoolerInfo == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCoolerInfo = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetCoolerInfo);

                /* "cuda/bindings/_internal/_nvml.pyx":967
 *         global __nvmlDeviceGetCoolerInfo
 *         __nvmlDeviceGetCoolerInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCoolerInfo')
 *         if __nvmlDeviceGetCoolerInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCoolerInfo == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":968
 *         __nvmlDeviceGetCoolerInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCoolerInfo')
 *         if __nvmlDeviceGetCoolerInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetCoolerInfo = dlsym(handle, 'nvmlDeviceGetCoolerInfo')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":969
 *         if __nvmlDeviceGetCoolerInfo == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetCoolerInfo = dlsym(handle, 'nvmlDeviceGetCoolerInfo')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 969, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":968
 *         __nvmlDeviceGetCoolerInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCoolerInfo')
 *         if __nvmlDeviceGetCoolerInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetCoolerInfo = dlsym(handle, 'nvmlDeviceGetCoolerInfo')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":970
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetCoolerInfo = dlsym(handle, 'nvmlDeviceGetCoolerInfo')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetTemperatureV
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCoolerInfo = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetCoolerInfo);

                  /* "cuda/bindings/_internal/_nvml.pyx":967
 *         global __nvmlDeviceGetCoolerInfo
 *         __nvmlDeviceGetCoolerInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCoolerInfo')
 *         if __nvmlDeviceGetCoolerInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":973
 * 
 *         global __nvmlDeviceGetTemperatureV
 *         __nvmlDeviceGetTemperatureV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTemperatureV')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetTemperatureV == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTemperatureV = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetTemperatureV);

                /* "cuda/bindings/_internal/_nvml.pyx":974
 *         global __nvmlDeviceGetTemperatureV
 *         __nvmlDeviceGetTemperatureV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTemperatureV')
 *         if __nvmlDeviceGetTemperatureV == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTemperatureV == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":975
 *         __nvmlDeviceGetTemperatureV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTemperatureV')
 *         if __nvmlDeviceGetTemperatureV == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetTemperatureV = dlsym(handle, 'nvmlDeviceGetTemperatureV')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":976
 *         if __nvmlDeviceGetTemperatureV == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetTemperatureV = dlsym(handle, 'nvmlDeviceGetTemperatureV')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 976, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":975
 *         __nvmlDeviceGetTemperatureV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTemperatureV')
 *         if __nvmlDeviceGetTemperatureV == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetTemperatureV = dlsym(handle, 'nvmlDeviceGetTemperatureV')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":977
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetTemperatureV = dlsym(handle, 'nvmlDeviceGetTemperatureV')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetTemperatureThreshold
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTemperatureV = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetTemperatureV);

                  /* "cuda/bindings/_internal/_nvml.pyx":974
 *         global __nvmlDeviceGetTemperatureV
 *         __nvmlDeviceGetTemperatureV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTemperatureV')
 *         if __nvmlDeviceGetTemperatureV == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":980
 * 
 *         global __nvmlDeviceGetTemperatureThreshold
 *         __nvmlDeviceGetTemperatureThreshold = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTemperatureThreshold')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetTemperatureThreshold == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTemperatureThreshold = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetTemperatureThreshol);

                /* "cuda/bindings/_internal/_nvml.pyx":981
 *         global __nvmlDeviceGetTemperatureThreshold
 *         __nvmlDeviceGetTemperatureThreshold = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTemperatureThreshold')
 *         if __nvmlDeviceGetTemperatureThreshold == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTemperatureThreshold == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":982
 *         __nvmlDeviceGetTemperatureThreshold = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTemperatureThreshold')
 *         if __nvmlDeviceGetTemperatureThreshold == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetTemperatureThreshold = dlsym(handle, 'nvmlDeviceGetTemperatureThreshold')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":983
 *         if __nvmlDeviceGetTemperatureThreshold == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetTemperatureThreshold = dlsym(handle, 'nvmlDeviceGetTemperatureThreshold')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 983, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":982
 *         __nvmlDeviceGetTemperatureThreshold = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTemperatureThreshold')
 *         if __nvmlDeviceGetTemperatureThreshold == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetTemperatureThreshold = dlsym(handle, 'nvmlDeviceGetTemperatureThreshold')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":984
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetTemperatureThreshold = dlsym(handle, 'nvmlDeviceGetTemperatureThreshold')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetMarginTemperature
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTemperatureThreshold = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetTemperatureThreshol);

                  /* "cuda/bindings/_internal/_nvml.pyx":981
 *         global __nvmlDeviceGetTemperatureThreshold
 *         __nvmlDeviceGetTemperatureThreshold = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTemperatureThreshold')
 *         if __nvmlDeviceGetTemperatureThreshold == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":987
 * 
 *         global __nvmlDeviceGetMarginTemperature
 *         __nvmlDeviceGetMarginTemperature = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMarginTemperature')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetMarginTemperature == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMarginTemperature = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetMarginTemperature);

                /* "cuda/bindings/_internal/_nvml.pyx":988
 *         global __nvmlDeviceGetMarginTemperature
 *         __nvmlDeviceGetMarginTemperature = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMarginTemperature')
 *         if __nvmlDeviceGetMarginTemperature == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMarginTemperature == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":989
 *         __nvmlDeviceGetMarginTemperature = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMarginTemperature')
 *         if __nvmlDeviceGetMarginTemperature == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMarginTemperature = dlsym(handle, 'nvmlDeviceGetMarginTemperature')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":990
 *         if __nvmlDeviceGetMarginTemperature == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetMarginTemperature = dlsym(handle, 'nvmlDeviceGetMarginTemperature')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 990, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":989
 *         __nvmlDeviceGetMarginTemperature = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMarginTemperature')
 *         if __nvmlDeviceGetMarginTemperature == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMarginTemperature = dlsym(handle, 'nvmlDeviceGetMarginTemperature')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":991
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetMarginTemperature = dlsym(handle, 'nvmlDeviceGetMarginTemperature')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetThermalSettings
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMarginTemperature = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetMarginTemperature);

                  /* "cuda/bindings/_internal/_nvml.pyx":988
 *         global __nvmlDeviceGetMarginTemperature
 *         __nvmlDeviceGetMarginTemperature = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMarginTemperature')
 *         if __nvmlDeviceGetMarginTemperature == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":994
 * 
 *         global __nvmlDeviceGetThermalSettings
 *         __nvmlDeviceGetThermalSettings = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetThermalSettings')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetThermalSettings == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetThermalSettings = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetThermalSettings);

                /* "cuda/bindings/_internal/_nvml.pyx":995
 *         global __nvmlDeviceGetThermalSettings
 *         __nvmlDeviceGetThermalSettings = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetThermalSettings')
 *         if __nvmlDeviceGetThermalSettings == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetThermalSettings == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":996
 *         __nvmlDeviceGetThermalSettings = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetThermalSettings')
 *         if __nvmlDeviceGetThermalSettings == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetThermalSettings = dlsym(handle, 'nvmlDeviceGetThermalSettings')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":997
 *         if __nvmlDeviceGetThermalSettings == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetThermalSettings = dlsym(handle, 'nvmlDeviceGetThermalSettings')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 997, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":996
 *         __nvmlDeviceGetThermalSettings = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetThermalSettings')
 *         if __nvmlDeviceGetThermalSettings == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetThermalSettings = dlsym(handle, 'nvmlDeviceGetThermalSettings')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":998
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetThermalSettings = dlsym(handle, 'nvmlDeviceGetThermalSettings')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetPerformanceState
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetThermalSettings = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetThermalSettings);

                  /* "cuda/bindings/_internal/_nvml.pyx":995
 *         global __nvmlDeviceGetThermalSettings
 *         __nvmlDeviceGetThermalSettings = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetThermalSettings')
 *         if __nvmlDeviceGetThermalSettings == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1001
 * 
 *         global __nvmlDeviceGetPerformanceState
 *         __nvmlDeviceGetPerformanceState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPerformanceState')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetPerformanceState == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPerformanceState = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetPerformanceState);

                /* "cuda/bindings/_internal/_nvml.pyx":1002
 *         global __nvmlDeviceGetPerformanceState
 *         __nvmlDeviceGetPerformanceState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPerformanceState')
 *         if __nvmlDeviceGetPerformanceState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPerformanceState == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1003
 *         __nvmlDeviceGetPerformanceState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPerformanceState')
 *         if __nvmlDeviceGetPerformanceState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPerformanceState = dlsym(handle, 'nvmlDeviceGetPerformanceState')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1004
 *         if __nvmlDeviceGetPerformanceState == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetPerformanceState = dlsym(handle, 'nvmlDeviceGetPerformanceState')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1004, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1003
 *         __nvmlDeviceGetPerformanceState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPerformanceState')
 *         if __nvmlDeviceGetPerformanceState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPerformanceState = dlsym(handle, 'nvmlDeviceGetPerformanceState')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1005
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetPerformanceState = dlsym(handle, 'nvmlDeviceGetPerformanceState')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetCurrentClocksEventReasons
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPerformanceState = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetPerformanceState);

                  /* "cuda/bindings/_internal/_nvml.pyx":1002
 *         global __nvmlDeviceGetPerformanceState
 *         __nvmlDeviceGetPerformanceState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPerformanceState')
 *         if __nvmlDeviceGetPerformanceState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1008
 * 
 *         global __nvmlDeviceGetCurrentClocksEventReasons
 *         __nvmlDeviceGetCurrentClocksEventReasons = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCurrentClocksEventReasons')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetCurrentClocksEventReasons == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrentClocksEventReasons = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetCurrentClocksEventR);

                /* "cuda/bindings/_internal/_nvml.pyx":1009
 *         global __nvmlDeviceGetCurrentClocksEventReasons
 *         __nvmlDeviceGetCurrentClocksEventReasons = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCurrentClocksEventReasons')
 *         if __nvmlDeviceGetCurrentClocksEventReasons == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrentClocksEventReasons == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1010
 *         __nvmlDeviceGetCurrentClocksEventReasons = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCurrentClocksEventReasons')
 *         if __nvmlDeviceGetCurrentClocksEventReasons == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetCurrentClocksEventReasons = dlsym(handle, 'nvmlDeviceGetCurrentClocksEventReasons')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1011
 *         if __nvmlDeviceGetCurrentClocksEventReasons == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetCurrentClocksEventReasons = dlsym(handle, 'nvmlDeviceGetCurrentClocksEventReasons')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1011, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1010
 *         __nvmlDeviceGetCurrentClocksEventReasons = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCurrentClocksEventReasons')
 *         if __nvmlDeviceGetCurrentClocksEventReasons == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetCurrentClocksEventReasons = dlsym(handle, 'nvmlDeviceGetCurrentClocksEventReasons')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1012
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetCurrentClocksEventReasons = dlsym(handle, 'nvmlDeviceGetCurrentClocksEventReasons')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetSupportedClocksEventReasons
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrentClocksEventReasons = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetCurrentClocksEventR);

                  /* "cuda/bindings/_internal/_nvml.pyx":1009
 *         global __nvmlDeviceGetCurrentClocksEventReasons
 *         __nvmlDeviceGetCurrentClocksEventReasons = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCurrentClocksEventReasons')
 *         if __nvmlDeviceGetCurrentClocksEventReasons == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1015
 * 
 *         global __nvmlDeviceGetSupportedClocksEventReasons
 *         __nvmlDeviceGetSupportedClocksEventReasons = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedClocksEventReasons')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetSupportedClocksEventReasons == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedClocksEventReasons = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetSupportedClocksEven);

                /* "cuda/bindings/_internal/_nvml.pyx":1016
 *         global __nvmlDeviceGetSupportedClocksEventReasons
 *         __nvmlDeviceGetSupportedClocksEventReasons = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedClocksEventReasons')
 *         if __nvmlDeviceGetSupportedClocksEventReasons == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedClocksEventReasons == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1017
 *         __nvmlDeviceGetSupportedClocksEventReasons = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedClocksEventReasons')
 *         if __nvmlDeviceGetSupportedClocksEventReasons == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetSupportedClocksEventReasons = dlsym(handle, 'nvmlDeviceGetSupportedClocksEventReasons')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1018
 *         if __nvmlDeviceGetSupportedClocksEventReasons == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetSupportedClocksEventReasons = dlsym(handle, 'nvmlDeviceGetSupportedClocksEventReasons')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1018, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1017
 *         __nvmlDeviceGetSupportedClocksEventReasons = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedClocksEventReasons')
 *         if __nvmlDeviceGetSupportedClocksEventReasons == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetSupportedClocksEventReasons = dlsym(handle, 'nvmlDeviceGetSupportedClocksEventReasons')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1019
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetSupportedClocksEventReasons = dlsym(handle, 'nvmlDeviceGetSupportedClocksEventReasons')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetPowerState
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedClocksEventReasons = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetSupportedClocksEven);

                  /* "cuda/bindings/_internal/_nvml.pyx":1016
 *         global __nvmlDeviceGetSupportedClocksEventReasons
 *         __nvmlDeviceGetSupportedClocksEventReasons = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedClocksEventReasons')
 *         if __nvmlDeviceGetSupportedClocksEventReasons == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1022
 * 
 *         global __nvmlDeviceGetPowerState
 *         __nvmlDeviceGetPowerState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerState')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetPowerState == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerState = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetPowerState);

                /* "cuda/bindings/_internal/_nvml.pyx":1023
 *         global __nvmlDeviceGetPowerState
 *         __nvmlDeviceGetPowerState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerState')
 *         if __nvmlDeviceGetPowerState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerState == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1024
 *         __nvmlDeviceGetPowerState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerState')
 *         if __nvmlDeviceGetPowerState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPowerState = dlsym(handle, 'nvmlDeviceGetPowerState')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1025
 *         if __nvmlDeviceGetPowerState == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetPowerState = dlsym(handle, 'nvmlDeviceGetPowerState')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1025, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1024
 *         __nvmlDeviceGetPowerState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerState')
 *         if __nvmlDeviceGetPowerState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPowerState = dlsym(handle, 'nvmlDeviceGetPowerState')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1026
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetPowerState = dlsym(handle, 'nvmlDeviceGetPowerState')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetDynamicPstatesInfo
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerState = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetPowerState);

                  /* "cuda/bindings/_internal/_nvml.pyx":1023
 *         global __nvmlDeviceGetPowerState
 *         __nvmlDeviceGetPowerState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerState')
 *         if __nvmlDeviceGetPowerState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1029
 * 
 *         global __nvmlDeviceGetDynamicPstatesInfo
 *         __nvmlDeviceGetDynamicPstatesInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDynamicPstatesInfo')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetDynamicPstatesInfo == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDynamicPstatesInfo = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetDynamicPstatesInfo);

                /* "cuda/bindings/_internal/_nvml.pyx":1030
 *         global __nvmlDeviceGetDynamicPstatesInfo
 *         __nvmlDeviceGetDynamicPstatesInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDynamicPstatesInfo')
 *         if __nvmlDeviceGetDynamicPstatesInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDynamicPstatesInfo == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1031
 *         __nvmlDeviceGetDynamicPstatesInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDynamicPstatesInfo')
 *         if __nvmlDeviceGetDynamicPstatesInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetDynamicPstatesInfo = dlsym(handle, 'nvmlDeviceGetDynamicPstatesInfo')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1032
 *         if __nvmlDeviceGetDynamicPstatesInfo == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetDynamicPstatesInfo = dlsym(handle, 'nvmlDeviceGetDynamicPstatesInfo')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1032, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1031
 *         __nvmlDeviceGetDynamicPstatesInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDynamicPstatesInfo')
 *         if __nvmlDeviceGetDynamicPstatesInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetDynamicPstatesInfo = dlsym(handle, 'nvmlDeviceGetDynamicPstatesInfo')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1033
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetDynamicPstatesInfo = dlsym(handle, 'nvmlDeviceGetDynamicPstatesInfo')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetMemClkVfOffset
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDynamicPstatesInfo = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetDynamicPstatesInfo);

                  /* "cuda/bindings/_internal/_nvml.pyx":1030
 *         global __nvmlDeviceGetDynamicPstatesInfo
 *         __nvmlDeviceGetDynamicPstatesInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDynamicPstatesInfo')
 *         if __nvmlDeviceGetDynamicPstatesInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1036
 * 
 *         global __nvmlDeviceGetMemClkVfOffset
 *         __nvmlDeviceGetMemClkVfOffset = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemClkVfOffset')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetMemClkVfOffset == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemClkVfOffset = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetMemClkVfOffset);

                /* "cuda/bindings/_internal/_nvml.pyx":1037
 *         global __nvmlDeviceGetMemClkVfOffset
 *         __nvmlDeviceGetMemClkVfOffset = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemClkVfOffset')
 *         if __nvmlDeviceGetMemClkVfOffset == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemClkVfOffset == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1038
 *         __nvmlDeviceGetMemClkVfOffset = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemClkVfOffset')
 *         if __nvmlDeviceGetMemClkVfOffset == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMemClkVfOffset = dlsym(handle, 'nvmlDeviceGetMemClkVfOffset')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1039
 *         if __nvmlDeviceGetMemClkVfOffset == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetMemClkVfOffset = dlsym(handle, 'nvmlDeviceGetMemClkVfOffset')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1039, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1038
 *         __nvmlDeviceGetMemClkVfOffset = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemClkVfOffset')
 *         if __nvmlDeviceGetMemClkVfOffset == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMemClkVfOffset = dlsym(handle, 'nvmlDeviceGetMemClkVfOffset')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1040
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetMemClkVfOffset = dlsym(handle, 'nvmlDeviceGetMemClkVfOffset')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetMinMaxClockOfPState
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemClkVfOffset = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetMemClkVfOffset);

                  /* "cuda/bindings/_internal/_nvml.pyx":1037
 *         global __nvmlDeviceGetMemClkVfOffset
 *         __nvmlDeviceGetMemClkVfOffset = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemClkVfOffset')
 *         if __nvmlDeviceGetMemClkVfOffset == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1043
 * 
 *         global __nvmlDeviceGetMinMaxClockOfPState
 *         __nvmlDeviceGetMinMaxClockOfPState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMinMaxClockOfPState')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetMinMaxClockOfPState == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMinMaxClockOfPState = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetMinMaxClockOfPState);

                /* "cuda/bindings/_internal/_nvml.pyx":1044
 *         global __nvmlDeviceGetMinMaxClockOfPState
 *         __nvmlDeviceGetMinMaxClockOfPState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMinMaxClockOfPState')
 *         if __nvmlDeviceGetMinMaxClockOfPState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMinMaxClockOfPState == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1045
 *         __nvmlDeviceGetMinMaxClockOfPState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMinMaxClockOfPState')
 *         if __nvmlDeviceGetMinMaxClockOfPState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMinMaxClockOfPState = dlsym(handle, 'nvmlDeviceGetMinMaxClockOfPState')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1046
 *         if __nvmlDeviceGetMinMaxClockOfPState == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetMinMaxClockOfPState = dlsym(handle, 'nvmlDeviceGetMinMaxClockOfPState')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1046, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1045
 *         __nvmlDeviceGetMinMaxClockOfPState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMinMaxClockOfPState')
 *         if __nvmlDeviceGetMinMaxClockOfPState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMinMaxClockOfPState = dlsym(handle, 'nvmlDeviceGetMinMaxClockOfPState')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1047
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetMinMaxClockOfPState = dlsym(handle, 'nvmlDeviceGetMinMaxClockOfPState')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetSupportedPerformanceStates
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMinMaxClockOfPState = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetMinMaxClockOfPState);

                  /* "cuda/bindings/_internal/_nvml.pyx":1044
 *         global __nvmlDeviceGetMinMaxClockOfPState
 *         __nvmlDeviceGetMinMaxClockOfPState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMinMaxClockOfPState')
 *         if __nvmlDeviceGetMinMaxClockOfPState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1050
 * 
 *         global __nvmlDeviceGetSupportedPerformanceStates
 *         __nvmlDeviceGetSupportedPerformanceStates = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedPerformanceStates')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetSupportedPerformanceStates == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedPerformanceStates = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetSupportedPerformanc);

                /* "cuda/bindings/_internal/_nvml.pyx":1051
 *         global __nvmlDeviceGetSupportedPerformanceStates
 *         __nvmlDeviceGetSupportedPerformanceStates = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedPerformanceStates')
 *         if __nvmlDeviceGetSupportedPerformanceStates == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedPerformanceStates == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1052
 *         __nvmlDeviceGetSupportedPerformanceStates = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedPerformanceStates')
 *         if __nvmlDeviceGetSupportedPerformanceStates == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetSupportedPerformanceStates = dlsym(handle, 'nvmlDeviceGetSupportedPerformanceStates')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1053
 *         if __nvmlDeviceGetSupportedPerformanceStates == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetSupportedPerformanceStates = dlsym(handle, 'nvmlDeviceGetSupportedPerformanceStates')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1053, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1052
 *         __nvmlDeviceGetSupportedPerformanceStates = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedPerformanceStates')
 *         if __nvmlDeviceGetSupportedPerformanceStates == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetSupportedPerformanceStates = dlsym(handle, 'nvmlDeviceGetSupportedPerformanceStates')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1054
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetSupportedPerformanceStates = dlsym(handle, 'nvmlDeviceGetSupportedPerformanceStates')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetGpcClkMinMaxVfOffset
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedPerformanceStates = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetSupportedPerformanc);

                  /* "cuda/bindings/_internal/_nvml.pyx":1051
 *         global __nvmlDeviceGetSupportedPerformanceStates
 *         __nvmlDeviceGetSupportedPerformanceStates = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedPerformanceStates')
 *         if __nvmlDeviceGetSupportedPerformanceStates == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1057
 * 
 *         global __nvmlDeviceGetGpcClkMinMaxVfOffset
 *         __nvmlDeviceGetGpcClkMinMaxVfOffset = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpcClkMinMaxVfOffset')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetGpcClkMinMaxVfOffset == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpcClkMinMaxVfOffset = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetGpcClkMinMaxVfOffse);

                /* "cuda/bindings/_internal/_nvml.pyx":1058
 *         global __nvmlDeviceGetGpcClkMinMaxVfOffset
 *         __nvmlDeviceGetGpcClkMinMaxVfOffset = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpcClkMinMaxVfOffset')
 *         if __nvmlDeviceGetGpcClkMinMaxVfOffset == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpcClkMinMaxVfOffset == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1059
 *         __nvmlDeviceGetGpcClkMinMaxVfOffset = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpcClkMinMaxVfOffset')
 *         if __nvmlDeviceGetGpcClkMinMaxVfOffset == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGpcClkMinMaxVfOffset = dlsym(handle, 'nvmlDeviceGetGpcClkMinMaxVfOffset')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1060
 *         if __nvmlDeviceGetGpcClkMinMaxVfOffset == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetGpcClkMinMaxVfOffset = dlsym(handle, 'nvmlDeviceGetGpcClkMinMaxVfOffset')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1060, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1059
 *         __nvmlDeviceGetGpcClkMinMaxVfOffset = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpcClkMinMaxVfOffset')
 *         if __nvmlDeviceGetGpcClkMinMaxVfOffset == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGpcClkMinMaxVfOffset = dlsym(handle, 'nvmlDeviceGetGpcClkMinMaxVfOffset')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1061
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetGpcClkMinMaxVfOffset = dlsym(handle, 'nvmlDeviceGetGpcClkMinMaxVfOffset')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetMemClkMinMaxVfOffset
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpcClkMinMaxVfOffset = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetGpcClkMinMaxVfOffse);

                  /* "cuda/bindings/_internal/_nvml.pyx":1058
 *         global __nvmlDeviceGetGpcClkMinMaxVfOffset
 *         __nvmlDeviceGetGpcClkMinMaxVfOffset = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpcClkMinMaxVfOffset')
 *         if __nvmlDeviceGetGpcClkMinMaxVfOffset == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1064
 * 
 *         global __nvmlDeviceGetMemClkMinMaxVfOffset
 *         __nvmlDeviceGetMemClkMinMaxVfOffset = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemClkMinMaxVfOffset')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetMemClkMinMaxVfOffset == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemClkMinMaxVfOffset = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetMemClkMinMaxVfOffse);

                /* "cuda/bindings/_internal/_nvml.pyx":1065
 *         global __nvmlDeviceGetMemClkMinMaxVfOffset
 *         __nvmlDeviceGetMemClkMinMaxVfOffset = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemClkMinMaxVfOffset')
 *         if __nvmlDeviceGetMemClkMinMaxVfOffset == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemClkMinMaxVfOffset == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1066
 *         __nvmlDeviceGetMemClkMinMaxVfOffset = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemClkMinMaxVfOffset')
 *         if __nvmlDeviceGetMemClkMinMaxVfOffset == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMemClkMinMaxVfOffset = dlsym(handle, 'nvmlDeviceGetMemClkMinMaxVfOffset')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1067
 *         if __nvmlDeviceGetMemClkMinMaxVfOffset == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetMemClkMinMaxVfOffset = dlsym(handle, 'nvmlDeviceGetMemClkMinMaxVfOffset')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1067, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1066
 *         __nvmlDeviceGetMemClkMinMaxVfOffset = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemClkMinMaxVfOffset')
 *         if __nvmlDeviceGetMemClkMinMaxVfOffset == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMemClkMinMaxVfOffset = dlsym(handle, 'nvmlDeviceGetMemClkMinMaxVfOffset')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1068
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetMemClkMinMaxVfOffset = dlsym(handle, 'nvmlDeviceGetMemClkMinMaxVfOffset')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetClockOffsets
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemClkMinMaxVfOffset = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetMemClkMinMaxVfOffse);

                  /* "cuda/bindings/_internal/_nvml.pyx":1065
 *         global __nvmlDeviceGetMemClkMinMaxVfOffset
 *         __nvmlDeviceGetMemClkMinMaxVfOffset = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemClkMinMaxVfOffset')
 *         if __nvmlDeviceGetMemClkMinMaxVfOffset == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1071
 * 
 *         global __nvmlDeviceGetClockOffsets
 *         __nvmlDeviceGetClockOffsets = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetClockOffsets')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetClockOffsets == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClockOffsets = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetClockOffsets);

                /* "cuda/bindings/_internal/_nvml.pyx":1072
 *         global __nvmlDeviceGetClockOffsets
 *         __nvmlDeviceGetClockOffsets = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetClockOffsets')
 *         if __nvmlDeviceGetClockOffsets == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClockOffsets == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1073
 *         __nvmlDeviceGetClockOffsets = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetClockOffsets')
 *         if __nvmlDeviceGetClockOffsets == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetClockOffsets = dlsym(handle, 'nvmlDeviceGetClockOffsets')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1074
 *         if __nvmlDeviceGetClockOffsets == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetClockOffsets = dlsym(handle, 'nvmlDeviceGetClockOffsets')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1074, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1073
 *         __nvmlDeviceGetClockOffsets = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetClockOffsets')
 *         if __nvmlDeviceGetClockOffsets == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetClockOffsets = dlsym(handle, 'nvmlDeviceGetClockOffsets')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1075
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetClockOffsets = dlsym(handle, 'nvmlDeviceGetClockOffsets')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetClockOffsets
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClockOffsets = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetClockOffsets);

                  /* "cuda/bindings/_internal/_nvml.pyx":1072
 *         global __nvmlDeviceGetClockOffsets
 *         __nvmlDeviceGetClockOffsets = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetClockOffsets')
 *         if __nvmlDeviceGetClockOffsets == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1078
 * 
 *         global __nvmlDeviceSetClockOffsets
 *         __nvmlDeviceSetClockOffsets = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetClockOffsets')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetClockOffsets == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetClockOffsets = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetClockOffsets);

                /* "cuda/bindings/_internal/_nvml.pyx":1079
 *         global __nvmlDeviceSetClockOffsets
 *         __nvmlDeviceSetClockOffsets = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetClockOffsets')
 *         if __nvmlDeviceSetClockOffsets == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetClockOffsets == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1080
 *         __nvmlDeviceSetClockOffsets = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetClockOffsets')
 *         if __nvmlDeviceSetClockOffsets == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetClockOffsets = dlsym(handle, 'nvmlDeviceSetClockOffsets')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1081
 *         if __nvmlDeviceSetClockOffsets == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetClockOffsets = dlsym(handle, 'nvmlDeviceSetClockOffsets')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1081, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1080
 *         __nvmlDeviceSetClockOffsets = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetClockOffsets')
 *         if __nvmlDeviceSetClockOffsets == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetClockOffsets = dlsym(handle, 'nvmlDeviceSetClockOffsets')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1082
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetClockOffsets = dlsym(handle, 'nvmlDeviceSetClockOffsets')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetPerformanceModes
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetClockOffsets = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetClockOffsets);

                  /* "cuda/bindings/_internal/_nvml.pyx":1079
 *         global __nvmlDeviceSetClockOffsets
 *         __nvmlDeviceSetClockOffsets = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetClockOffsets')
 *         if __nvmlDeviceSetClockOffsets == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1085
 * 
 *         global __nvmlDeviceGetPerformanceModes
 *         __nvmlDeviceGetPerformanceModes = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPerformanceModes')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetPerformanceModes == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPerformanceModes = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetPerformanceModes);

                /* "cuda/bindings/_internal/_nvml.pyx":1086
 *         global __nvmlDeviceGetPerformanceModes
 *         __nvmlDeviceGetPerformanceModes = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPerformanceModes')
 *         if __nvmlDeviceGetPerformanceModes == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPerformanceModes == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1087
 *         __nvmlDeviceGetPerformanceModes = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPerformanceModes')
 *         if __nvmlDeviceGetPerformanceModes == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPerformanceModes = dlsym(handle, 'nvmlDeviceGetPerformanceModes')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1088
 *         if __nvmlDeviceGetPerformanceModes == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetPerformanceModes = dlsym(handle, 'nvmlDeviceGetPerformanceModes')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1088, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1087
 *         __nvmlDeviceGetPerformanceModes = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPerformanceModes')
 *         if __nvmlDeviceGetPerformanceModes == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPerformanceModes = dlsym(handle, 'nvmlDeviceGetPerformanceModes')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1089
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetPerformanceModes = dlsym(handle, 'nvmlDeviceGetPerformanceModes')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetCurrentClockFreqs
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPerformanceModes = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetPerformanceModes);

                  /* "cuda/bindings/_internal/_nvml.pyx":1086
 *         global __nvmlDeviceGetPerformanceModes
 *         __nvmlDeviceGetPerformanceModes = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPerformanceModes')
 *         if __nvmlDeviceGetPerformanceModes == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1092
 * 
 *         global __nvmlDeviceGetCurrentClockFreqs
 *         __nvmlDeviceGetCurrentClockFreqs = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCurrentClockFreqs')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetCurrentClockFreqs == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrentClockFreqs = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetCurrentClockFreqs);

                /* "cuda/bindings/_internal/_nvml.pyx":1093
 *         global __nvmlDeviceGetCurrentClockFreqs
 *         __nvmlDeviceGetCurrentClockFreqs = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCurrentClockFreqs')
 *         if __nvmlDeviceGetCurrentClockFreqs == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrentClockFreqs == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1094
 *         __nvmlDeviceGetCurrentClockFreqs = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCurrentClockFreqs')
 *         if __nvmlDeviceGetCurrentClockFreqs == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetCurrentClockFreqs = dlsym(handle, 'nvmlDeviceGetCurrentClockFreqs')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1095
 *         if __nvmlDeviceGetCurrentClockFreqs == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetCurrentClockFreqs = dlsym(handle, 'nvmlDeviceGetCurrentClockFreqs')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1095, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1094
 *         __nvmlDeviceGetCurrentClockFreqs = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCurrentClockFreqs')
 *         if __nvmlDeviceGetCurrentClockFreqs == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetCurrentClockFreqs = dlsym(handle, 'nvmlDeviceGetCurrentClockFreqs')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1096
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetCurrentClockFreqs = dlsym(handle, 'nvmlDeviceGetCurrentClockFreqs')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetPowerManagementLimit
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrentClockFreqs = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetCurrentClockFreqs);

                  /* "cuda/bindings/_internal/_nvml.pyx":1093
 *         global __nvmlDeviceGetCurrentClockFreqs
 *         __nvmlDeviceGetCurrentClockFreqs = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCurrentClockFreqs')
 *         if __nvmlDeviceGetCurrentClockFreqs == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1099
 * 
 *         global __nvmlDeviceGetPowerManagementLimit
 *         __nvmlDeviceGetPowerManagementLimit = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerManagementLimit')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetPowerManagementLimit == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerManagementLimit = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetPowerManagementLimi);

                /* "cuda/bindings/_internal/_nvml.pyx":1100
 *         global __nvmlDeviceGetPowerManagementLimit
 *         __nvmlDeviceGetPowerManagementLimit = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerManagementLimit')
 *         if __nvmlDeviceGetPowerManagementLimit == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerManagementLimit == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1101
 *         __nvmlDeviceGetPowerManagementLimit = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerManagementLimit')
 *         if __nvmlDeviceGetPowerManagementLimit == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPowerManagementLimit = dlsym(handle, 'nvmlDeviceGetPowerManagementLimit')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1102
 *         if __nvmlDeviceGetPowerManagementLimit == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetPowerManagementLimit = dlsym(handle, 'nvmlDeviceGetPowerManagementLimit')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1102, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1101
 *         __nvmlDeviceGetPowerManagementLimit = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerManagementLimit')
 *         if __nvmlDeviceGetPowerManagementLimit == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPowerManagementLimit = dlsym(handle, 'nvmlDeviceGetPowerManagementLimit')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1103
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetPowerManagementLimit = dlsym(handle, 'nvmlDeviceGetPowerManagementLimit')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetPowerManagementLimitConstraints
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerManagementLimit = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetPowerManagementLimi);

                  /* "cuda/bindings/_internal/_nvml.pyx":1100
 *         global __nvmlDeviceGetPowerManagementLimit
 *         __nvmlDeviceGetPowerManagementLimit = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerManagementLimit')
 *         if __nvmlDeviceGetPowerManagementLimit == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1106
 * 
 *         global __nvmlDeviceGetPowerManagementLimitConstraints
 *         __nvmlDeviceGetPowerManagementLimitConstraints = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerManagementLimitConstraints')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetPowerManagementLimitConstraints == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerManagementLimitConstraints = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetPowerManagementLimi_2);

                /* "cuda/bindings/_internal/_nvml.pyx":1107
 *         global __nvmlDeviceGetPowerManagementLimitConstraints
 *         __nvmlDeviceGetPowerManagementLimitConstraints = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerManagementLimitConstraints')
 *         if __nvmlDeviceGetPowerManagementLimitConstraints == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerManagementLimitConstraints == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1108
 *         __nvmlDeviceGetPowerManagementLimitConstraints = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerManagementLimitConstraints')
 *         if __nvmlDeviceGetPowerManagementLimitConstraints == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPowerManagementLimitConstraints = dlsym(handle, 'nvmlDeviceGetPowerManagementLimitConstraints')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1109
 *         if __nvmlDeviceGetPowerManagementLimitConstraints == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetPowerManagementLimitConstraints = dlsym(handle, 'nvmlDeviceGetPowerManagementLimitConstraints')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1109, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1108
 *         __nvmlDeviceGetPowerManagementLimitConstraints = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerManagementLimitConstraints')
 *         if __nvmlDeviceGetPowerManagementLimitConstraints == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPowerManagementLimitConstraints = dlsym(handle, 'nvmlDeviceGetPowerManagementLimitConstraints')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1110
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetPowerManagementLimitConstraints = dlsym(handle, 'nvmlDeviceGetPowerManagementLimitConstraints')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetPowerManagementDefaultLimit
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerManagementLimitConstraints = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetPowerManagementLimi_2);

                  /* "cuda/bindings/_internal/_nvml.pyx":1107
 *         global __nvmlDeviceGetPowerManagementLimitConstraints
 *         __nvmlDeviceGetPowerManagementLimitConstraints = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerManagementLimitConstraints')
 *         if __nvmlDeviceGetPowerManagementLimitConstraints == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1113
 * 
 *         global __nvmlDeviceGetPowerManagementDefaultLimit
 *         __nvmlDeviceGetPowerManagementDefaultLimit = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerManagementDefaultLimit')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetPowerManagementDefaultLimit == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerManagementDefaultLimit = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetPowerManagementDefa);

                /* "cuda/bindings/_internal/_nvml.pyx":1114
 *         global __nvmlDeviceGetPowerManagementDefaultLimit
 *         __nvmlDeviceGetPowerManagementDefaultLimit = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerManagementDefaultLimit')
 *         if __nvmlDeviceGetPowerManagementDefaultLimit == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerManagementDefaultLimit == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1115
 *         __nvmlDeviceGetPowerManagementDefaultLimit = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerManagementDefaultLimit')
 *         if __nvmlDeviceGetPowerManagementDefaultLimit == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPowerManagementDefaultLimit = dlsym(handle, 'nvmlDeviceGetPowerManagementDefaultLimit')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1116
 *         if __nvmlDeviceGetPowerManagementDefaultLimit == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetPowerManagementDefaultLimit = dlsym(handle, 'nvmlDeviceGetPowerManagementDefaultLimit')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1116, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1115
 *         __nvmlDeviceGetPowerManagementDefaultLimit = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerManagementDefaultLimit')
 *         if __nvmlDeviceGetPowerManagementDefaultLimit == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPowerManagementDefaultLimit = dlsym(handle, 'nvmlDeviceGetPowerManagementDefaultLimit')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1117
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetPowerManagementDefaultLimit = dlsym(handle, 'nvmlDeviceGetPowerManagementDefaultLimit')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetPowerUsage
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerManagementDefaultLimit = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetPowerManagementDefa);

                  /* "cuda/bindings/_internal/_nvml.pyx":1114
 *         global __nvmlDeviceGetPowerManagementDefaultLimit
 *         __nvmlDeviceGetPowerManagementDefaultLimit = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerManagementDefaultLimit')
 *         if __nvmlDeviceGetPowerManagementDefaultLimit == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1120
 * 
 *         global __nvmlDeviceGetPowerUsage
 *         __nvmlDeviceGetPowerUsage = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerUsage')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetPowerUsage == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerUsage = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetPowerUsage);

                /* "cuda/bindings/_internal/_nvml.pyx":1121
 *         global __nvmlDeviceGetPowerUsage
 *         __nvmlDeviceGetPowerUsage = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerUsage')
 *         if __nvmlDeviceGetPowerUsage == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerUsage == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1122
 *         __nvmlDeviceGetPowerUsage = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerUsage')
 *         if __nvmlDeviceGetPowerUsage == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPowerUsage = dlsym(handle, 'nvmlDeviceGetPowerUsage')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1123
 *         if __nvmlDeviceGetPowerUsage == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetPowerUsage = dlsym(handle, 'nvmlDeviceGetPowerUsage')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1123, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1122
 *         __nvmlDeviceGetPowerUsage = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerUsage')
 *         if __nvmlDeviceGetPowerUsage == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPowerUsage = dlsym(handle, 'nvmlDeviceGetPowerUsage')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1124
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetPowerUsage = dlsym(handle, 'nvmlDeviceGetPowerUsage')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetTotalEnergyConsumption
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerUsage = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetPowerUsage);

                  /* "cuda/bindings/_internal/_nvml.pyx":1121
 *         global __nvmlDeviceGetPowerUsage
 *         __nvmlDeviceGetPowerUsage = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerUsage')
 *         if __nvmlDeviceGetPowerUsage == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1127
 * 
 *         global __nvmlDeviceGetTotalEnergyConsumption
 *         __nvmlDeviceGetTotalEnergyConsumption = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTotalEnergyConsumption')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetTotalEnergyConsumption == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTotalEnergyConsumption = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetTotalEnergyConsumpt);

                /* "cuda/bindings/_internal/_nvml.pyx":1128
 *         global __nvmlDeviceGetTotalEnergyConsumption
 *         __nvmlDeviceGetTotalEnergyConsumption = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTotalEnergyConsumption')
 *         if __nvmlDeviceGetTotalEnergyConsumption == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTotalEnergyConsumption == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1129
 *         __nvmlDeviceGetTotalEnergyConsumption = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTotalEnergyConsumption')
 *         if __nvmlDeviceGetTotalEnergyConsumption == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetTotalEnergyConsumption = dlsym(handle, 'nvmlDeviceGetTotalEnergyConsumption')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1130
 *         if __nvmlDeviceGetTotalEnergyConsumption == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetTotalEnergyConsumption = dlsym(handle, 'nvmlDeviceGetTotalEnergyConsumption')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1130, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1129
 *         __nvmlDeviceGetTotalEnergyConsumption = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTotalEnergyConsumption')
 *         if __nvmlDeviceGetTotalEnergyConsumption == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetTotalEnergyConsumption = dlsym(handle, 'nvmlDeviceGetTotalEnergyConsumption')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1131
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetTotalEnergyConsumption = dlsym(handle, 'nvmlDeviceGetTotalEnergyConsumption')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetEnforcedPowerLimit
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTotalEnergyConsumption = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetTotalEnergyConsumpt);

                  /* "cuda/bindings/_internal/_nvml.pyx":1128
 *         global __nvmlDeviceGetTotalEnergyConsumption
 *         __nvmlDeviceGetTotalEnergyConsumption = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTotalEnergyConsumption')
 *         if __nvmlDeviceGetTotalEnergyConsumption == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1134
 * 
 *         global __nvmlDeviceGetEnforcedPowerLimit
 *         __nvmlDeviceGetEnforcedPowerLimit = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEnforcedPowerLimit')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetEnforcedPowerLimit == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEnforcedPowerLimit = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetEnforcedPowerLimit);

                /* "cuda/bindings/_internal/_nvml.pyx":1135
 *         global __nvmlDeviceGetEnforcedPowerLimit
 *         __nvmlDeviceGetEnforcedPowerLimit = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEnforcedPowerLimit')
 *         if __nvmlDeviceGetEnforcedPowerLimit == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEnforcedPowerLimit == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1136
 *         __nvmlDeviceGetEnforcedPowerLimit = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEnforcedPowerLimit')
 *         if __nvmlDeviceGetEnforcedPowerLimit == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetEnforcedPowerLimit = dlsym(handle, 'nvmlDeviceGetEnforcedPowerLimit')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1137
 *         if __nvmlDeviceGetEnforcedPowerLimit == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetEnforcedPowerLimit = dlsym(handle, 'nvmlDeviceGetEnforcedPowerLimit')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1137, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1136
 *         __nvmlDeviceGetEnforcedPowerLimit = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEnforcedPowerLimit')
 *         if __nvmlDeviceGetEnforcedPowerLimit == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetEnforcedPowerLimit = dlsym(handle, 'nvmlDeviceGetEnforcedPowerLimit')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1138
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetEnforcedPowerLimit = dlsym(handle, 'nvmlDeviceGetEnforcedPowerLimit')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetGpuOperationMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEnforcedPowerLimit = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetEnforcedPowerLimit);

                  /* "cuda/bindings/_internal/_nvml.pyx":1135
 *         global __nvmlDeviceGetEnforcedPowerLimit
 *         __nvmlDeviceGetEnforcedPowerLimit = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEnforcedPowerLimit')
 *         if __nvmlDeviceGetEnforcedPowerLimit == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1141
 * 
 *         global __nvmlDeviceGetGpuOperationMode
 *         __nvmlDeviceGetGpuOperationMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuOperationMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetGpuOperationMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuOperationMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetGpuOperationMode);

                /* "cuda/bindings/_internal/_nvml.pyx":1142
 *         global __nvmlDeviceGetGpuOperationMode
 *         __nvmlDeviceGetGpuOperationMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuOperationMode')
 *         if __nvmlDeviceGetGpuOperationMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuOperationMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1143
 *         __nvmlDeviceGetGpuOperationMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuOperationMode')
 *         if __nvmlDeviceGetGpuOperationMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuOperationMode = dlsym(handle, 'nvmlDeviceGetGpuOperationMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1144
 *         if __nvmlDeviceGetGpuOperationMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetGpuOperationMode = dlsym(handle, 'nvmlDeviceGetGpuOperationMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1144, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1143
 *         __nvmlDeviceGetGpuOperationMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuOperationMode')
 *         if __nvmlDeviceGetGpuOperationMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuOperationMode = dlsym(handle, 'nvmlDeviceGetGpuOperationMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1145
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuOperationMode = dlsym(handle, 'nvmlDeviceGetGpuOperationMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetMemoryInfo_v2
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuOperationMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetGpuOperationMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":1142
 *         global __nvmlDeviceGetGpuOperationMode
 *         __nvmlDeviceGetGpuOperationMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuOperationMode')
 *         if __nvmlDeviceGetGpuOperationMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1148
 * 
 *         global __nvmlDeviceGetMemoryInfo_v2
 *         __nvmlDeviceGetMemoryInfo_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemoryInfo_v2')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetMemoryInfo_v2 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryInfo_v2 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetMemoryInfo_v2);

                /* "cuda/bindings/_internal/_nvml.pyx":1149
 *         global __nvmlDeviceGetMemoryInfo_v2
 *         __nvmlDeviceGetMemoryInfo_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemoryInfo_v2')
 *         if __nvmlDeviceGetMemoryInfo_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryInfo_v2 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1150
 *         __nvmlDeviceGetMemoryInfo_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemoryInfo_v2')
 *         if __nvmlDeviceGetMemoryInfo_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMemoryInfo_v2 = dlsym(handle, 'nvmlDeviceGetMemoryInfo_v2')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1151
 *         if __nvmlDeviceGetMemoryInfo_v2 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetMemoryInfo_v2 = dlsym(handle, 'nvmlDeviceGetMemoryInfo_v2')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1151, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1150
 *         __nvmlDeviceGetMemoryInfo_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemoryInfo_v2')
 *         if __nvmlDeviceGetMemoryInfo_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMemoryInfo_v2 = dlsym(handle, 'nvmlDeviceGetMemoryInfo_v2')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1152
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetMemoryInfo_v2 = dlsym(handle, 'nvmlDeviceGetMemoryInfo_v2')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetComputeMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryInfo_v2 = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetMemoryInfo_v2);

                  /* "cuda/bindings/_internal/_nvml.pyx":1149
 *         global __nvmlDeviceGetMemoryInfo_v2
 *         __nvmlDeviceGetMemoryInfo_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemoryInfo_v2')
 *         if __nvmlDeviceGetMemoryInfo_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1155
 * 
 *         global __nvmlDeviceGetComputeMode
 *         __nvmlDeviceGetComputeMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetComputeMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetComputeMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetComputeMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetComputeMode);

                /* "cuda/bindings/_internal/_nvml.pyx":1156
 *         global __nvmlDeviceGetComputeMode
 *         __nvmlDeviceGetComputeMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetComputeMode')
 *         if __nvmlDeviceGetComputeMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetComputeMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1157
 *         __nvmlDeviceGetComputeMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetComputeMode')
 *         if __nvmlDeviceGetComputeMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetComputeMode = dlsym(handle, 'nvmlDeviceGetComputeMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1158
 *         if __nvmlDeviceGetComputeMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetComputeMode = dlsym(handle, 'nvmlDeviceGetComputeMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1158, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1157
 *         __nvmlDeviceGetComputeMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetComputeMode')
 *         if __nvmlDeviceGetComputeMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetComputeMode = dlsym(handle, 'nvmlDeviceGetComputeMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1159
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetComputeMode = dlsym(handle, 'nvmlDeviceGetComputeMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetCudaComputeCapability
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetComputeMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetComputeMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":1156
 *         global __nvmlDeviceGetComputeMode
 *         __nvmlDeviceGetComputeMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetComputeMode')
 *         if __nvmlDeviceGetComputeMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1162
 * 
 *         global __nvmlDeviceGetCudaComputeCapability
 *         __nvmlDeviceGetCudaComputeCapability = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCudaComputeCapability')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetCudaComputeCapability == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCudaComputeCapability = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetCudaComputeCapabili);

                /* "cuda/bindings/_internal/_nvml.pyx":1163
 *         global __nvmlDeviceGetCudaComputeCapability
 *         __nvmlDeviceGetCudaComputeCapability = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCudaComputeCapability')
 *         if __nvmlDeviceGetCudaComputeCapability == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCudaComputeCapability == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1164
 *         __nvmlDeviceGetCudaComputeCapability = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCudaComputeCapability')
 *         if __nvmlDeviceGetCudaComputeCapability == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetCudaComputeCapability = dlsym(handle, 'nvmlDeviceGetCudaComputeCapability')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1165
 *         if __nvmlDeviceGetCudaComputeCapability == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetCudaComputeCapability = dlsym(handle, 'nvmlDeviceGetCudaComputeCapability')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1165, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1164
 *         __nvmlDeviceGetCudaComputeCapability = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCudaComputeCapability')
 *         if __nvmlDeviceGetCudaComputeCapability == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetCudaComputeCapability = dlsym(handle, 'nvmlDeviceGetCudaComputeCapability')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1166
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetCudaComputeCapability = dlsym(handle, 'nvmlDeviceGetCudaComputeCapability')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetDramEncryptionMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCudaComputeCapability = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetCudaComputeCapabili);

                  /* "cuda/bindings/_internal/_nvml.pyx":1163
 *         global __nvmlDeviceGetCudaComputeCapability
 *         __nvmlDeviceGetCudaComputeCapability = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCudaComputeCapability')
 *         if __nvmlDeviceGetCudaComputeCapability == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1169
 * 
 *         global __nvmlDeviceGetDramEncryptionMode
 *         __nvmlDeviceGetDramEncryptionMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDramEncryptionMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetDramEncryptionMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDramEncryptionMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetDramEncryptionMode);

                /* "cuda/bindings/_internal/_nvml.pyx":1170
 *         global __nvmlDeviceGetDramEncryptionMode
 *         __nvmlDeviceGetDramEncryptionMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDramEncryptionMode')
 *         if __nvmlDeviceGetDramEncryptionMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDramEncryptionMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1171
 *         __nvmlDeviceGetDramEncryptionMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDramEncryptionMode')
 *         if __nvmlDeviceGetDramEncryptionMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetDramEncryptionMode = dlsym(handle, 'nvmlDeviceGetDramEncryptionMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1172
 *         if __nvmlDeviceGetDramEncryptionMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetDramEncryptionMode = dlsym(handle, 'nvmlDeviceGetDramEncryptionMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1172, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1171
 *         __nvmlDeviceGetDramEncryptionMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDramEncryptionMode')
 *         if __nvmlDeviceGetDramEncryptionMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetDramEncryptionMode = dlsym(handle, 'nvmlDeviceGetDramEncryptionMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1173
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetDramEncryptionMode = dlsym(handle, 'nvmlDeviceGetDramEncryptionMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetDramEncryptionMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDramEncryptionMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetDramEncryptionMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":1170
 *         global __nvmlDeviceGetDramEncryptionMode
 *         __nvmlDeviceGetDramEncryptionMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDramEncryptionMode')
 *         if __nvmlDeviceGetDramEncryptionMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1176
 * 
 *         global __nvmlDeviceSetDramEncryptionMode
 *         __nvmlDeviceSetDramEncryptionMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetDramEncryptionMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetDramEncryptionMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDramEncryptionMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetDramEncryptionMode);

                /* "cuda/bindings/_internal/_nvml.pyx":1177
 *         global __nvmlDeviceSetDramEncryptionMode
 *         __nvmlDeviceSetDramEncryptionMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetDramEncryptionMode')
 *         if __nvmlDeviceSetDramEncryptionMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDramEncryptionMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1178
 *         __nvmlDeviceSetDramEncryptionMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetDramEncryptionMode')
 *         if __nvmlDeviceSetDramEncryptionMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetDramEncryptionMode = dlsym(handle, 'nvmlDeviceSetDramEncryptionMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1179
 *         if __nvmlDeviceSetDramEncryptionMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetDramEncryptionMode = dlsym(handle, 'nvmlDeviceSetDramEncryptionMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1179, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1178
 *         __nvmlDeviceSetDramEncryptionMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetDramEncryptionMode')
 *         if __nvmlDeviceSetDramEncryptionMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetDramEncryptionMode = dlsym(handle, 'nvmlDeviceSetDramEncryptionMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1180
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetDramEncryptionMode = dlsym(handle, 'nvmlDeviceSetDramEncryptionMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetEccMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDramEncryptionMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetDramEncryptionMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":1177
 *         global __nvmlDeviceSetDramEncryptionMode
 *         __nvmlDeviceSetDramEncryptionMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetDramEncryptionMode')
 *         if __nvmlDeviceSetDramEncryptionMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1183
 * 
 *         global __nvmlDeviceGetEccMode
 *         __nvmlDeviceGetEccMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEccMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetEccMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEccMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetEccMode);

                /* "cuda/bindings/_internal/_nvml.pyx":1184
 *         global __nvmlDeviceGetEccMode
 *         __nvmlDeviceGetEccMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEccMode')
 *         if __nvmlDeviceGetEccMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEccMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1185
 *         __nvmlDeviceGetEccMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEccMode')
 *         if __nvmlDeviceGetEccMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetEccMode = dlsym(handle, 'nvmlDeviceGetEccMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1186
 *         if __nvmlDeviceGetEccMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetEccMode = dlsym(handle, 'nvmlDeviceGetEccMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1186, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1185
 *         __nvmlDeviceGetEccMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEccMode')
 *         if __nvmlDeviceGetEccMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetEccMode = dlsym(handle, 'nvmlDeviceGetEccMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1187
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetEccMode = dlsym(handle, 'nvmlDeviceGetEccMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetDefaultEccMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEccMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetEccMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":1184
 *         global __nvmlDeviceGetEccMode
 *         __nvmlDeviceGetEccMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEccMode')
 *         if __nvmlDeviceGetEccMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1190
 * 
 *         global __nvmlDeviceGetDefaultEccMode
 *         __nvmlDeviceGetDefaultEccMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDefaultEccMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetDefaultEccMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDefaultEccMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetDefaultEccMode);

                /* "cuda/bindings/_internal/_nvml.pyx":1191
 *         global __nvmlDeviceGetDefaultEccMode
 *         __nvmlDeviceGetDefaultEccMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDefaultEccMode')
 *         if __nvmlDeviceGetDefaultEccMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDefaultEccMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1192
 *         __nvmlDeviceGetDefaultEccMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDefaultEccMode')
 *         if __nvmlDeviceGetDefaultEccMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetDefaultEccMode = dlsym(handle, 'nvmlDeviceGetDefaultEccMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1193
 *         if __nvmlDeviceGetDefaultEccMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetDefaultEccMode = dlsym(handle, 'nvmlDeviceGetDefaultEccMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1193, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1192
 *         __nvmlDeviceGetDefaultEccMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDefaultEccMode')
 *         if __nvmlDeviceGetDefaultEccMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetDefaultEccMode = dlsym(handle, 'nvmlDeviceGetDefaultEccMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1194
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetDefaultEccMode = dlsym(handle, 'nvmlDeviceGetDefaultEccMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetBoardId
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDefaultEccMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetDefaultEccMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":1191
 *         global __nvmlDeviceGetDefaultEccMode
 *         __nvmlDeviceGetDefaultEccMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDefaultEccMode')
 *         if __nvmlDeviceGetDefaultEccMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1197
 * 
 *         global __nvmlDeviceGetBoardId
 *         __nvmlDeviceGetBoardId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBoardId')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetBoardId == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBoardId = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetBoardId);

                /* "cuda/bindings/_internal/_nvml.pyx":1198
 *         global __nvmlDeviceGetBoardId
 *         __nvmlDeviceGetBoardId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBoardId')
 *         if __nvmlDeviceGetBoardId == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBoardId == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1199
 *         __nvmlDeviceGetBoardId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBoardId')
 *         if __nvmlDeviceGetBoardId == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetBoardId = dlsym(handle, 'nvmlDeviceGetBoardId')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1200
 *         if __nvmlDeviceGetBoardId == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetBoardId = dlsym(handle, 'nvmlDeviceGetBoardId')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1200, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1199
 *         __nvmlDeviceGetBoardId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBoardId')
 *         if __nvmlDeviceGetBoardId == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetBoardId = dlsym(handle, 'nvmlDeviceGetBoardId')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1201
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetBoardId = dlsym(handle, 'nvmlDeviceGetBoardId')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetMultiGpuBoard
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBoardId = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetBoardId);

                  /* "cuda/bindings/_internal/_nvml.pyx":1198
 *         global __nvmlDeviceGetBoardId
 *         __nvmlDeviceGetBoardId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBoardId')
 *         if __nvmlDeviceGetBoardId == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1204
 * 
 *         global __nvmlDeviceGetMultiGpuBoard
 *         __nvmlDeviceGetMultiGpuBoard = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMultiGpuBoard')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetMultiGpuBoard == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMultiGpuBoard = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetMultiGpuBoard);

                /* "cuda/bindings/_internal/_nvml.pyx":1205
 *         global __nvmlDeviceGetMultiGpuBoard
 *         __nvmlDeviceGetMultiGpuBoard = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMultiGpuBoard')
 *         if __nvmlDeviceGetMultiGpuBoard == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMultiGpuBoard == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1206
 *         __nvmlDeviceGetMultiGpuBoard = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMultiGpuBoard')
 *         if __nvmlDeviceGetMultiGpuBoard == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMultiGpuBoard = dlsym(handle, 'nvmlDeviceGetMultiGpuBoard')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1207
 *         if __nvmlDeviceGetMultiGpuBoard == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetMultiGpuBoard = dlsym(handle, 'nvmlDeviceGetMultiGpuBoard')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1207, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1206
 *         __nvmlDeviceGetMultiGpuBoard = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMultiGpuBoard')
 *         if __nvmlDeviceGetMultiGpuBoard == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMultiGpuBoard = dlsym(handle, 'nvmlDeviceGetMultiGpuBoard')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1208
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetMultiGpuBoard = dlsym(handle, 'nvmlDeviceGetMultiGpuBoard')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetTotalEccErrors
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMultiGpuBoard = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetMultiGpuBoard);

                  /* "cuda/bindings/_internal/_nvml.pyx":1205
 *         global __nvmlDeviceGetMultiGpuBoard
 *         __nvmlDeviceGetMultiGpuBoard = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMultiGpuBoard')
 *         if __nvmlDeviceGetMultiGpuBoard == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1211
 * 
 *         global __nvmlDeviceGetTotalEccErrors
 *         __nvmlDeviceGetTotalEccErrors = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTotalEccErrors')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetTotalEccErrors == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTotalEccErrors = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetTotalEccErrors);

                /* "cuda/bindings/_internal/_nvml.pyx":1212
 *         global __nvmlDeviceGetTotalEccErrors
 *         __nvmlDeviceGetTotalEccErrors = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTotalEccErrors')
 *         if __nvmlDeviceGetTotalEccErrors == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTotalEccErrors == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1213
 *         __nvmlDeviceGetTotalEccErrors = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTotalEccErrors')
 *         if __nvmlDeviceGetTotalEccErrors == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetTotalEccErrors = dlsym(handle, 'nvmlDeviceGetTotalEccErrors')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1214
 *         if __nvmlDeviceGetTotalEccErrors == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetTotalEccErrors = dlsym(handle, 'nvmlDeviceGetTotalEccErrors')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1214, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1213
 *         __nvmlDeviceGetTotalEccErrors = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTotalEccErrors')
 *         if __nvmlDeviceGetTotalEccErrors == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetTotalEccErrors = dlsym(handle, 'nvmlDeviceGetTotalEccErrors')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1215
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetTotalEccErrors = dlsym(handle, 'nvmlDeviceGetTotalEccErrors')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetMemoryErrorCounter
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTotalEccErrors = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetTotalEccErrors);

                  /* "cuda/bindings/_internal/_nvml.pyx":1212
 *         global __nvmlDeviceGetTotalEccErrors
 *         __nvmlDeviceGetTotalEccErrors = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetTotalEccErrors')
 *         if __nvmlDeviceGetTotalEccErrors == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1218
 * 
 *         global __nvmlDeviceGetMemoryErrorCounter
 *         __nvmlDeviceGetMemoryErrorCounter = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemoryErrorCounter')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetMemoryErrorCounter == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryErrorCounter = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetMemoryErrorCounter);

                /* "cuda/bindings/_internal/_nvml.pyx":1219
 *         global __nvmlDeviceGetMemoryErrorCounter
 *         __nvmlDeviceGetMemoryErrorCounter = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemoryErrorCounter')
 *         if __nvmlDeviceGetMemoryErrorCounter == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryErrorCounter == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1220
 *         __nvmlDeviceGetMemoryErrorCounter = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemoryErrorCounter')
 *         if __nvmlDeviceGetMemoryErrorCounter == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMemoryErrorCounter = dlsym(handle, 'nvmlDeviceGetMemoryErrorCounter')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1221
 *         if __nvmlDeviceGetMemoryErrorCounter == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetMemoryErrorCounter = dlsym(handle, 'nvmlDeviceGetMemoryErrorCounter')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1221, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1220
 *         __nvmlDeviceGetMemoryErrorCounter = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemoryErrorCounter')
 *         if __nvmlDeviceGetMemoryErrorCounter == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMemoryErrorCounter = dlsym(handle, 'nvmlDeviceGetMemoryErrorCounter')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1222
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetMemoryErrorCounter = dlsym(handle, 'nvmlDeviceGetMemoryErrorCounter')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetUtilizationRates
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryErrorCounter = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetMemoryErrorCounter);

                  /* "cuda/bindings/_internal/_nvml.pyx":1219
 *         global __nvmlDeviceGetMemoryErrorCounter
 *         __nvmlDeviceGetMemoryErrorCounter = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemoryErrorCounter')
 *         if __nvmlDeviceGetMemoryErrorCounter == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1225
 * 
 *         global __nvmlDeviceGetUtilizationRates
 *         __nvmlDeviceGetUtilizationRates = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetUtilizationRates')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetUtilizationRates == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetUtilizationRates = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetUtilizationRates);

                /* "cuda/bindings/_internal/_nvml.pyx":1226
 *         global __nvmlDeviceGetUtilizationRates
 *         __nvmlDeviceGetUtilizationRates = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetUtilizationRates')
 *         if __nvmlDeviceGetUtilizationRates == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetUtilizationRates == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1227
 *         __nvmlDeviceGetUtilizationRates = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetUtilizationRates')
 *         if __nvmlDeviceGetUtilizationRates == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetUtilizationRates = dlsym(handle, 'nvmlDeviceGetUtilizationRates')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1228
 *         if __nvmlDeviceGetUtilizationRates == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetUtilizationRates = dlsym(handle, 'nvmlDeviceGetUtilizationRates')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1228, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1227
 *         __nvmlDeviceGetUtilizationRates = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetUtilizationRates')
 *         if __nvmlDeviceGetUtilizationRates == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetUtilizationRates = dlsym(handle, 'nvmlDeviceGetUtilizationRates')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1229
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetUtilizationRates = dlsym(handle, 'nvmlDeviceGetUtilizationRates')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetEncoderUtilization
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetUtilizationRates = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetUtilizationRates);

                  /* "cuda/bindings/_internal/_nvml.pyx":1226
 *         global __nvmlDeviceGetUtilizationRates
 *         __nvmlDeviceGetUtilizationRates = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetUtilizationRates')
 *         if __nvmlDeviceGetUtilizationRates == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1232
 * 
 *         global __nvmlDeviceGetEncoderUtilization
 *         __nvmlDeviceGetEncoderUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEncoderUtilization')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetEncoderUtilization == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderUtilization = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetEncoderUtilization);

                /* "cuda/bindings/_internal/_nvml.pyx":1233
 *         global __nvmlDeviceGetEncoderUtilization
 *         __nvmlDeviceGetEncoderUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEncoderUtilization')
 *         if __nvmlDeviceGetEncoderUtilization == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderUtilization == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1234
 *         __nvmlDeviceGetEncoderUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEncoderUtilization')
 *         if __nvmlDeviceGetEncoderUtilization == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetEncoderUtilization = dlsym(handle, 'nvmlDeviceGetEncoderUtilization')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1235
 *         if __nvmlDeviceGetEncoderUtilization == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetEncoderUtilization = dlsym(handle, 'nvmlDeviceGetEncoderUtilization')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1235, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1234
 *         __nvmlDeviceGetEncoderUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEncoderUtilization')
 *         if __nvmlDeviceGetEncoderUtilization == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetEncoderUtilization = dlsym(handle, 'nvmlDeviceGetEncoderUtilization')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1236
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetEncoderUtilization = dlsym(handle, 'nvmlDeviceGetEncoderUtilization')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetEncoderCapacity
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderUtilization = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetEncoderUtilization);

                  /* "cuda/bindings/_internal/_nvml.pyx":1233
 *         global __nvmlDeviceGetEncoderUtilization
 *         __nvmlDeviceGetEncoderUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEncoderUtilization')
 *         if __nvmlDeviceGetEncoderUtilization == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1239
 * 
 *         global __nvmlDeviceGetEncoderCapacity
 *         __nvmlDeviceGetEncoderCapacity = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEncoderCapacity')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetEncoderCapacity == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderCapacity = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetEncoderCapacity);

                /* "cuda/bindings/_internal/_nvml.pyx":1240
 *         global __nvmlDeviceGetEncoderCapacity
 *         __nvmlDeviceGetEncoderCapacity = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEncoderCapacity')
 *         if __nvmlDeviceGetEncoderCapacity == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderCapacity == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1241
 *         __nvmlDeviceGetEncoderCapacity = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEncoderCapacity')
 *         if __nvmlDeviceGetEncoderCapacity == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetEncoderCapacity = dlsym(handle, 'nvmlDeviceGetEncoderCapacity')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1242
 *         if __nvmlDeviceGetEncoderCapacity == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetEncoderCapacity = dlsym(handle, 'nvmlDeviceGetEncoderCapacity')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1242, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1241
 *         __nvmlDeviceGetEncoderCapacity = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEncoderCapacity')
 *         if __nvmlDeviceGetEncoderCapacity == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetEncoderCapacity = dlsym(handle, 'nvmlDeviceGetEncoderCapacity')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1243
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetEncoderCapacity = dlsym(handle, 'nvmlDeviceGetEncoderCapacity')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetEncoderStats
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderCapacity = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetEncoderCapacity);

                  /* "cuda/bindings/_internal/_nvml.pyx":1240
 *         global __nvmlDeviceGetEncoderCapacity
 *         __nvmlDeviceGetEncoderCapacity = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEncoderCapacity')
 *         if __nvmlDeviceGetEncoderCapacity == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1246
 * 
 *         global __nvmlDeviceGetEncoderStats
 *         __nvmlDeviceGetEncoderStats = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEncoderStats')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetEncoderStats == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderStats = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetEncoderStats);

                /* "cuda/bindings/_internal/_nvml.pyx":1247
 *         global __nvmlDeviceGetEncoderStats
 *         __nvmlDeviceGetEncoderStats = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEncoderStats')
 *         if __nvmlDeviceGetEncoderStats == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderStats == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1248
 *         __nvmlDeviceGetEncoderStats = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEncoderStats')
 *         if __nvmlDeviceGetEncoderStats == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetEncoderStats = dlsym(handle, 'nvmlDeviceGetEncoderStats')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1249
 *         if __nvmlDeviceGetEncoderStats == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetEncoderStats = dlsym(handle, 'nvmlDeviceGetEncoderStats')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1249, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1248
 *         __nvmlDeviceGetEncoderStats = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEncoderStats')
 *         if __nvmlDeviceGetEncoderStats == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetEncoderStats = dlsym(handle, 'nvmlDeviceGetEncoderStats')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1250
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetEncoderStats = dlsym(handle, 'nvmlDeviceGetEncoderStats')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetEncoderSessions
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderStats = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetEncoderStats);

                  /* "cuda/bindings/_internal/_nvml.pyx":1247
 *         global __nvmlDeviceGetEncoderStats
 *         __nvmlDeviceGetEncoderStats = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEncoderStats')
 *         if __nvmlDeviceGetEncoderStats == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1253
 * 
 *         global __nvmlDeviceGetEncoderSessions
 *         __nvmlDeviceGetEncoderSessions = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEncoderSessions')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetEncoderSessions == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderSessions = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetEncoderSessions);

                /* "cuda/bindings/_internal/_nvml.pyx":1254
 *         global __nvmlDeviceGetEncoderSessions
 *         __nvmlDeviceGetEncoderSessions = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEncoderSessions')
 *         if __nvmlDeviceGetEncoderSessions == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderSessions == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1255
 *         __nvmlDeviceGetEncoderSessions = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEncoderSessions')
 *         if __nvmlDeviceGetEncoderSessions == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetEncoderSessions = dlsym(handle, 'nvmlDeviceGetEncoderSessions')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1256
 *         if __nvmlDeviceGetEncoderSessions == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetEncoderSessions = dlsym(handle, 'nvmlDeviceGetEncoderSessions')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1256, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1255
 *         __nvmlDeviceGetEncoderSessions = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEncoderSessions')
 *         if __nvmlDeviceGetEncoderSessions == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetEncoderSessions = dlsym(handle, 'nvmlDeviceGetEncoderSessions')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1257
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetEncoderSessions = dlsym(handle, 'nvmlDeviceGetEncoderSessions')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetDecoderUtilization
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderSessions = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetEncoderSessions);

                  /* "cuda/bindings/_internal/_nvml.pyx":1254
 *         global __nvmlDeviceGetEncoderSessions
 *         __nvmlDeviceGetEncoderSessions = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetEncoderSessions')
 *         if __nvmlDeviceGetEncoderSessions == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1260
 * 
 *         global __nvmlDeviceGetDecoderUtilization
 *         __nvmlDeviceGetDecoderUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDecoderUtilization')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetDecoderUtilization == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDecoderUtilization = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetDecoderUtilization);

                /* "cuda/bindings/_internal/_nvml.pyx":1261
 *         global __nvmlDeviceGetDecoderUtilization
 *         __nvmlDeviceGetDecoderUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDecoderUtilization')
 *         if __nvmlDeviceGetDecoderUtilization == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDecoderUtilization == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1262
 *         __nvmlDeviceGetDecoderUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDecoderUtilization')
 *         if __nvmlDeviceGetDecoderUtilization == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetDecoderUtilization = dlsym(handle, 'nvmlDeviceGetDecoderUtilization')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1263
 *         if __nvmlDeviceGetDecoderUtilization == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetDecoderUtilization = dlsym(handle, 'nvmlDeviceGetDecoderUtilization')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1263, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1262
 *         __nvmlDeviceGetDecoderUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDecoderUtilization')
 *         if __nvmlDeviceGetDecoderUtilization == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetDecoderUtilization = dlsym(handle, 'nvmlDeviceGetDecoderUtilization')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1264
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetDecoderUtilization = dlsym(handle, 'nvmlDeviceGetDecoderUtilization')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetJpgUtilization
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDecoderUtilization = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetDecoderUtilization);

                  /* "cuda/bindings/_internal/_nvml.pyx":1261
 *         global __nvmlDeviceGetDecoderUtilization
 *         __nvmlDeviceGetDecoderUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDecoderUtilization')
 *         if __nvmlDeviceGetDecoderUtilization == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1267
 * 
 *         global __nvmlDeviceGetJpgUtilization
 *         __nvmlDeviceGetJpgUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetJpgUtilization')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetJpgUtilization == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetJpgUtilization = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetJpgUtilization);

                /* "cuda/bindings/_internal/_nvml.pyx":1268
 *         global __nvmlDeviceGetJpgUtilization
 *         __nvmlDeviceGetJpgUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetJpgUtilization')
 *         if __nvmlDeviceGetJpgUtilization == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetJpgUtilization == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1269
 *         __nvmlDeviceGetJpgUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetJpgUtilization')
 *         if __nvmlDeviceGetJpgUtilization == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetJpgUtilization = dlsym(handle, 'nvmlDeviceGetJpgUtilization')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1270
 *         if __nvmlDeviceGetJpgUtilization == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetJpgUtilization = dlsym(handle, 'nvmlDeviceGetJpgUtilization')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1270, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1269
 *         __nvmlDeviceGetJpgUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetJpgUtilization')
 *         if __nvmlDeviceGetJpgUtilization == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetJpgUtilization = dlsym(handle, 'nvmlDeviceGetJpgUtilization')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1271
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetJpgUtilization = dlsym(handle, 'nvmlDeviceGetJpgUtilization')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetOfaUtilization
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetJpgUtilization = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetJpgUtilization);

                  /* "cuda/bindings/_internal/_nvml.pyx":1268
 *         global __nvmlDeviceGetJpgUtilization
 *         __nvmlDeviceGetJpgUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetJpgUtilization')
 *         if __nvmlDeviceGetJpgUtilization == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1274
 * 
 *         global __nvmlDeviceGetOfaUtilization
 *         __nvmlDeviceGetOfaUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetOfaUtilization')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetOfaUtilization == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetOfaUtilization = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetOfaUtilization);

                /* "cuda/bindings/_internal/_nvml.pyx":1275
 *         global __nvmlDeviceGetOfaUtilization
 *         __nvmlDeviceGetOfaUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetOfaUtilization')
 *         if __nvmlDeviceGetOfaUtilization == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetOfaUtilization == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1276
 *         __nvmlDeviceGetOfaUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetOfaUtilization')
 *         if __nvmlDeviceGetOfaUtilization == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetOfaUtilization = dlsym(handle, 'nvmlDeviceGetOfaUtilization')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1277
 *         if __nvmlDeviceGetOfaUtilization == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetOfaUtilization = dlsym(handle, 'nvmlDeviceGetOfaUtilization')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1277, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1276
 *         __nvmlDeviceGetOfaUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetOfaUtilization')
 *         if __nvmlDeviceGetOfaUtilization == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetOfaUtilization = dlsym(handle, 'nvmlDeviceGetOfaUtilization')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1278
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetOfaUtilization = dlsym(handle, 'nvmlDeviceGetOfaUtilization')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetFBCStats
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetOfaUtilization = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetOfaUtilization);

                  /* "cuda/bindings/_internal/_nvml.pyx":1275
 *         global __nvmlDeviceGetOfaUtilization
 *         __nvmlDeviceGetOfaUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetOfaUtilization')
 *         if __nvmlDeviceGetOfaUtilization == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1281
 * 
 *         global __nvmlDeviceGetFBCStats
 *         __nvmlDeviceGetFBCStats = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFBCStats')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetFBCStats == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFBCStats = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetFBCStats);

                /* "cuda/bindings/_internal/_nvml.pyx":1282
 *         global __nvmlDeviceGetFBCStats
 *         __nvmlDeviceGetFBCStats = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFBCStats')
 *         if __nvmlDeviceGetFBCStats == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFBCStats == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1283
 *         __nvmlDeviceGetFBCStats = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFBCStats')
 *         if __nvmlDeviceGetFBCStats == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetFBCStats = dlsym(handle, 'nvmlDeviceGetFBCStats')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1284
 *         if __nvmlDeviceGetFBCStats == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetFBCStats = dlsym(handle, 'nvmlDeviceGetFBCStats')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1284, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1283
 *         __nvmlDeviceGetFBCStats = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFBCStats')
 *         if __nvmlDeviceGetFBCStats == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetFBCStats = dlsym(handle, 'nvmlDeviceGetFBCStats')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1285
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetFBCStats = dlsym(handle, 'nvmlDeviceGetFBCStats')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetFBCSessions
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFBCStats = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetFBCStats);

                  /* "cuda/bindings/_internal/_nvml.pyx":1282
 *         global __nvmlDeviceGetFBCStats
 *         __nvmlDeviceGetFBCStats = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFBCStats')
 *         if __nvmlDeviceGetFBCStats == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1288
 * 
 *         global __nvmlDeviceGetFBCSessions
 *         __nvmlDeviceGetFBCSessions = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFBCSessions')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetFBCSessions == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFBCSessions = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetFBCSessions);

                /* "cuda/bindings/_internal/_nvml.pyx":1289
 *         global __nvmlDeviceGetFBCSessions
 *         __nvmlDeviceGetFBCSessions = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFBCSessions')
 *         if __nvmlDeviceGetFBCSessions == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFBCSessions == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1290
 *         __nvmlDeviceGetFBCSessions = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFBCSessions')
 *         if __nvmlDeviceGetFBCSessions == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetFBCSessions = dlsym(handle, 'nvmlDeviceGetFBCSessions')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1291
 *         if __nvmlDeviceGetFBCSessions == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetFBCSessions = dlsym(handle, 'nvmlDeviceGetFBCSessions')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1291, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1290
 *         __nvmlDeviceGetFBCSessions = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFBCSessions')
 *         if __nvmlDeviceGetFBCSessions == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetFBCSessions = dlsym(handle, 'nvmlDeviceGetFBCSessions')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1292
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetFBCSessions = dlsym(handle, 'nvmlDeviceGetFBCSessions')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetDriverModel_v2
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFBCSessions = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetFBCSessions);

                  /* "cuda/bindings/_internal/_nvml.pyx":1289
 *         global __nvmlDeviceGetFBCSessions
 *         __nvmlDeviceGetFBCSessions = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFBCSessions')
 *         if __nvmlDeviceGetFBCSessions == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1295
 * 
 *         global __nvmlDeviceGetDriverModel_v2
 *         __nvmlDeviceGetDriverModel_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDriverModel_v2')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetDriverModel_v2 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDriverModel_v2 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetDriverModel_v2);

                /* "cuda/bindings/_internal/_nvml.pyx":1296
 *         global __nvmlDeviceGetDriverModel_v2
 *         __nvmlDeviceGetDriverModel_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDriverModel_v2')
 *         if __nvmlDeviceGetDriverModel_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDriverModel_v2 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1297
 *         __nvmlDeviceGetDriverModel_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDriverModel_v2')
 *         if __nvmlDeviceGetDriverModel_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetDriverModel_v2 = dlsym(handle, 'nvmlDeviceGetDriverModel_v2')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1298
 *         if __nvmlDeviceGetDriverModel_v2 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetDriverModel_v2 = dlsym(handle, 'nvmlDeviceGetDriverModel_v2')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1298, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1297
 *         __nvmlDeviceGetDriverModel_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDriverModel_v2')
 *         if __nvmlDeviceGetDriverModel_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetDriverModel_v2 = dlsym(handle, 'nvmlDeviceGetDriverModel_v2')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1299
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetDriverModel_v2 = dlsym(handle, 'nvmlDeviceGetDriverModel_v2')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetVbiosVersion
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDriverModel_v2 = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetDriverModel_v2);

                  /* "cuda/bindings/_internal/_nvml.pyx":1296
 *         global __nvmlDeviceGetDriverModel_v2
 *         __nvmlDeviceGetDriverModel_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDriverModel_v2')
 *         if __nvmlDeviceGetDriverModel_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1302
 * 
 *         global __nvmlDeviceGetVbiosVersion
 *         __nvmlDeviceGetVbiosVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVbiosVersion')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetVbiosVersion == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVbiosVersion = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetVbiosVersion);

                /* "cuda/bindings/_internal/_nvml.pyx":1303
 *         global __nvmlDeviceGetVbiosVersion
 *         __nvmlDeviceGetVbiosVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVbiosVersion')
 *         if __nvmlDeviceGetVbiosVersion == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVbiosVersion == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1304
 *         __nvmlDeviceGetVbiosVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVbiosVersion')
 *         if __nvmlDeviceGetVbiosVersion == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVbiosVersion = dlsym(handle, 'nvmlDeviceGetVbiosVersion')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1305
 *         if __nvmlDeviceGetVbiosVersion == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetVbiosVersion = dlsym(handle, 'nvmlDeviceGetVbiosVersion')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1305, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1304
 *         __nvmlDeviceGetVbiosVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVbiosVersion')
 *         if __nvmlDeviceGetVbiosVersion == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVbiosVersion = dlsym(handle, 'nvmlDeviceGetVbiosVersion')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1306
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetVbiosVersion = dlsym(handle, 'nvmlDeviceGetVbiosVersion')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetBridgeChipInfo
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVbiosVersion = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetVbiosVersion);

                  /* "cuda/bindings/_internal/_nvml.pyx":1303
 *         global __nvmlDeviceGetVbiosVersion
 *         __nvmlDeviceGetVbiosVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVbiosVersion')
 *         if __nvmlDeviceGetVbiosVersion == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1309
 * 
 *         global __nvmlDeviceGetBridgeChipInfo
 *         __nvmlDeviceGetBridgeChipInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBridgeChipInfo')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetBridgeChipInfo == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBridgeChipInfo = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetBridgeChipInfo);

                /* "cuda/bindings/_internal/_nvml.pyx":1310
 *         global __nvmlDeviceGetBridgeChipInfo
 *         __nvmlDeviceGetBridgeChipInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBridgeChipInfo')
 *         if __nvmlDeviceGetBridgeChipInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBridgeChipInfo == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1311
 *         __nvmlDeviceGetBridgeChipInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBridgeChipInfo')
 *         if __nvmlDeviceGetBridgeChipInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetBridgeChipInfo = dlsym(handle, 'nvmlDeviceGetBridgeChipInfo')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1312
 *         if __nvmlDeviceGetBridgeChipInfo == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetBridgeChipInfo = dlsym(handle, 'nvmlDeviceGetBridgeChipInfo')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1312, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1311
 *         __nvmlDeviceGetBridgeChipInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBridgeChipInfo')
 *         if __nvmlDeviceGetBridgeChipInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetBridgeChipInfo = dlsym(handle, 'nvmlDeviceGetBridgeChipInfo')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1313
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetBridgeChipInfo = dlsym(handle, 'nvmlDeviceGetBridgeChipInfo')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetComputeRunningProcesses_v3
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBridgeChipInfo = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetBridgeChipInfo);

                  /* "cuda/bindings/_internal/_nvml.pyx":1310
 *         global __nvmlDeviceGetBridgeChipInfo
 *         __nvmlDeviceGetBridgeChipInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBridgeChipInfo')
 *         if __nvmlDeviceGetBridgeChipInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1316
 * 
 *         global __nvmlDeviceGetComputeRunningProcesses_v3
 *         __nvmlDeviceGetComputeRunningProcesses_v3 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetComputeRunningProcesses_v3')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetComputeRunningProcesses_v3 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetComputeRunningProcesses_v3 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetComputeRunningProce);

                /* "cuda/bindings/_internal/_nvml.pyx":1317
 *         global __nvmlDeviceGetComputeRunningProcesses_v3
 *         __nvmlDeviceGetComputeRunningProcesses_v3 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetComputeRunningProcesses_v3')
 *         if __nvmlDeviceGetComputeRunningProcesses_v3 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetComputeRunningProcesses_v3 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1318
 *         __nvmlDeviceGetComputeRunningProcesses_v3 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetComputeRunningProcesses_v3')
 *         if __nvmlDeviceGetComputeRunningProcesses_v3 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetComputeRunningProcesses_v3 = dlsym(handle, 'nvmlDeviceGetComputeRunningProcesses_v3')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1319
 *         if __nvmlDeviceGetComputeRunningProcesses_v3 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetComputeRunningProcesses_v3 = dlsym(handle, 'nvmlDeviceGetComputeRunningProcesses_v3')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1319, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1318
 *         __nvmlDeviceGetComputeRunningProcesses_v3 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetComputeRunningProcesses_v3')
 *         if __nvmlDeviceGetComputeRunningProcesses_v3 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetComputeRunningProcesses_v3 = dlsym(handle, 'nvmlDeviceGetComputeRunningProcesses_v3')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1320
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetComputeRunningProcesses_v3 = dlsym(handle, 'nvmlDeviceGetComputeRunningProcesses_v3')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetMPSComputeRunningProcesses_v3
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetComputeRunningProcesses_v3 = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetComputeRunningProce);

                  /* "cuda/bindings/_internal/_nvml.pyx":1317
 *         global __nvmlDeviceGetComputeRunningProcesses_v3
 *         __nvmlDeviceGetComputeRunningProcesses_v3 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetComputeRunningProcesses_v3')
 *         if __nvmlDeviceGetComputeRunningProcesses_v3 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1323
 * 
 *         global __nvmlDeviceGetMPSComputeRunningProcesses_v3
 *         __nvmlDeviceGetMPSComputeRunningProcesses_v3 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMPSComputeRunningProcesses_v3')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetMPSComputeRunningProcesses_v3 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMPSComputeRunningProcesses_v3 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetMPSComputeRunningPr);

                /* "cuda/bindings/_internal/_nvml.pyx":1324
 *         global __nvmlDeviceGetMPSComputeRunningProcesses_v3
 *         __nvmlDeviceGetMPSComputeRunningProcesses_v3 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMPSComputeRunningProcesses_v3')
 *         if __nvmlDeviceGetMPSComputeRunningProcesses_v3 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMPSComputeRunningProcesses_v3 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1325
 *         __nvmlDeviceGetMPSComputeRunningProcesses_v3 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMPSComputeRunningProcesses_v3')
 *         if __nvmlDeviceGetMPSComputeRunningProcesses_v3 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMPSComputeRunningProcesses_v3 = dlsym(handle, 'nvmlDeviceGetMPSComputeRunningProcesses_v3')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1326
 *         if __nvmlDeviceGetMPSComputeRunningProcesses_v3 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetMPSComputeRunningProcesses_v3 = dlsym(handle, 'nvmlDeviceGetMPSComputeRunningProcesses_v3')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1326, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1325
 *         __nvmlDeviceGetMPSComputeRunningProcesses_v3 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMPSComputeRunningProcesses_v3')
 *         if __nvmlDeviceGetMPSComputeRunningProcesses_v3 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMPSComputeRunningProcesses_v3 = dlsym(handle, 'nvmlDeviceGetMPSComputeRunningProcesses_v3')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1327
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetMPSComputeRunningProcesses_v3 = dlsym(handle, 'nvmlDeviceGetMPSComputeRunningProcesses_v3')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetRunningProcessDetailList
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMPSComputeRunningProcesses_v3 = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetMPSComputeRunningPr);

                  /* "cuda/bindings/_internal/_nvml.pyx":1324
 *         global __nvmlDeviceGetMPSComputeRunningProcesses_v3
 *         __nvmlDeviceGetMPSComputeRunningProcesses_v3 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMPSComputeRunningProcesses_v3')
 *         if __nvmlDeviceGetMPSComputeRunningProcesses_v3 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1330
 * 
 *         global __nvmlDeviceGetRunningProcessDetailList
 *         __nvmlDeviceGetRunningProcessDetailList = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRunningProcessDetailList')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetRunningProcessDetailList == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRunningProcessDetailList = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetRunningProcessDetai);

                /* "cuda/bindings/_internal/_nvml.pyx":1331
 *         global __nvmlDeviceGetRunningProcessDetailList
 *         __nvmlDeviceGetRunningProcessDetailList = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRunningProcessDetailList')
 *         if __nvmlDeviceGetRunningProcessDetailList == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRunningProcessDetailList == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1332
 *         __nvmlDeviceGetRunningProcessDetailList = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRunningProcessDetailList')
 *         if __nvmlDeviceGetRunningProcessDetailList == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetRunningProcessDetailList = dlsym(handle, 'nvmlDeviceGetRunningProcessDetailList')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1333
 *         if __nvmlDeviceGetRunningProcessDetailList == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetRunningProcessDetailList = dlsym(handle, 'nvmlDeviceGetRunningProcessDetailList')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1333, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1332
 *         __nvmlDeviceGetRunningProcessDetailList = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRunningProcessDetailList')
 *         if __nvmlDeviceGetRunningProcessDetailList == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetRunningProcessDetailList = dlsym(handle, 'nvmlDeviceGetRunningProcessDetailList')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1334
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetRunningProcessDetailList = dlsym(handle, 'nvmlDeviceGetRunningProcessDetailList')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceOnSameBoard
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRunningProcessDetailList = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetRunningProcessDetai);

                  /* "cuda/bindings/_internal/_nvml.pyx":1331
 *         global __nvmlDeviceGetRunningProcessDetailList
 *         __nvmlDeviceGetRunningProcessDetailList = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRunningProcessDetailList')
 *         if __nvmlDeviceGetRunningProcessDetailList == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1337
 * 
 *         global __nvmlDeviceOnSameBoard
 *         __nvmlDeviceOnSameBoard = dlsym(RTLD_DEFAULT, 'nvmlDeviceOnSameBoard')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceOnSameBoard == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceOnSameBoard = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceOnSameBoard);

                /* "cuda/bindings/_internal/_nvml.pyx":1338
 *         global __nvmlDeviceOnSameBoard
 *         __nvmlDeviceOnSameBoard = dlsym(RTLD_DEFAULT, 'nvmlDeviceOnSameBoard')
 *         if __nvmlDeviceOnSameBoard == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceOnSameBoard == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1339
 *         __nvmlDeviceOnSameBoard = dlsym(RTLD_DEFAULT, 'nvmlDeviceOnSameBoard')
 *         if __nvmlDeviceOnSameBoard == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceOnSameBoard = dlsym(handle, 'nvmlDeviceOnSameBoard')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1340
 *         if __nvmlDeviceOnSameBoard == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceOnSameBoard = dlsym(handle, 'nvmlDeviceOnSameBoard')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1340, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1339
 *         __nvmlDeviceOnSameBoard = dlsym(RTLD_DEFAULT, 'nvmlDeviceOnSameBoard')
 *         if __nvmlDeviceOnSameBoard == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceOnSameBoard = dlsym(handle, 'nvmlDeviceOnSameBoard')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1341
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceOnSameBoard = dlsym(handle, 'nvmlDeviceOnSameBoard')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetAPIRestriction
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceOnSameBoard = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceOnSameBoard);

                  /* "cuda/bindings/_internal/_nvml.pyx":1338
 *         global __nvmlDeviceOnSameBoard
 *         __nvmlDeviceOnSameBoard = dlsym(RTLD_DEFAULT, 'nvmlDeviceOnSameBoard')
 *         if __nvmlDeviceOnSameBoard == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1344
 * 
 *         global __nvmlDeviceGetAPIRestriction
 *         __nvmlDeviceGetAPIRestriction = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAPIRestriction')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetAPIRestriction == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAPIRestriction = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetAPIRestriction);

                /* "cuda/bindings/_internal/_nvml.pyx":1345
 *         global __nvmlDeviceGetAPIRestriction
 *         __nvmlDeviceGetAPIRestriction = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAPIRestriction')
 *         if __nvmlDeviceGetAPIRestriction == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAPIRestriction == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1346
 *         __nvmlDeviceGetAPIRestriction = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAPIRestriction')
 *         if __nvmlDeviceGetAPIRestriction == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetAPIRestriction = dlsym(handle, 'nvmlDeviceGetAPIRestriction')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1347
 *         if __nvmlDeviceGetAPIRestriction == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetAPIRestriction = dlsym(handle, 'nvmlDeviceGetAPIRestriction')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1347, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1346
 *         __nvmlDeviceGetAPIRestriction = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAPIRestriction')
 *         if __nvmlDeviceGetAPIRestriction == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetAPIRestriction = dlsym(handle, 'nvmlDeviceGetAPIRestriction')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1348
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetAPIRestriction = dlsym(handle, 'nvmlDeviceGetAPIRestriction')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetSamples
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAPIRestriction = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetAPIRestriction);

                  /* "cuda/bindings/_internal/_nvml.pyx":1345
 *         global __nvmlDeviceGetAPIRestriction
 *         __nvmlDeviceGetAPIRestriction = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAPIRestriction')
 *         if __nvmlDeviceGetAPIRestriction == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1351
 * 
 *         global __nvmlDeviceGetSamples
 *         __nvmlDeviceGetSamples = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSamples')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetSamples == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSamples = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetSamples);

                /* "cuda/bindings/_internal/_nvml.pyx":1352
 *         global __nvmlDeviceGetSamples
 *         __nvmlDeviceGetSamples = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSamples')
 *         if __nvmlDeviceGetSamples == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSamples == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1353
 *         __nvmlDeviceGetSamples = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSamples')
 *         if __nvmlDeviceGetSamples == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetSamples = dlsym(handle, 'nvmlDeviceGetSamples')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1354
 *         if __nvmlDeviceGetSamples == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetSamples = dlsym(handle, 'nvmlDeviceGetSamples')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1354, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1353
 *         __nvmlDeviceGetSamples = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSamples')
 *         if __nvmlDeviceGetSamples == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetSamples = dlsym(handle, 'nvmlDeviceGetSamples')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1355
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetSamples = dlsym(handle, 'nvmlDeviceGetSamples')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetBAR1MemoryInfo
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSamples = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetSamples);

                  /* "cuda/bindings/_internal/_nvml.pyx":1352
 *         global __nvmlDeviceGetSamples
 *         __nvmlDeviceGetSamples = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSamples')
 *         if __nvmlDeviceGetSamples == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1358
 * 
 *         global __nvmlDeviceGetBAR1MemoryInfo
 *         __nvmlDeviceGetBAR1MemoryInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBAR1MemoryInfo')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetBAR1MemoryInfo == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBAR1MemoryInfo = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetBAR1MemoryInfo);

                /* "cuda/bindings/_internal/_nvml.pyx":1359
 *         global __nvmlDeviceGetBAR1MemoryInfo
 *         __nvmlDeviceGetBAR1MemoryInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBAR1MemoryInfo')
 *         if __nvmlDeviceGetBAR1MemoryInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBAR1MemoryInfo == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1360
 *         __nvmlDeviceGetBAR1MemoryInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBAR1MemoryInfo')
 *         if __nvmlDeviceGetBAR1MemoryInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetBAR1MemoryInfo = dlsym(handle, 'nvmlDeviceGetBAR1MemoryInfo')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1361
 *         if __nvmlDeviceGetBAR1MemoryInfo == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetBAR1MemoryInfo = dlsym(handle, 'nvmlDeviceGetBAR1MemoryInfo')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1361, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1360
 *         __nvmlDeviceGetBAR1MemoryInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBAR1MemoryInfo')
 *         if __nvmlDeviceGetBAR1MemoryInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetBAR1MemoryInfo = dlsym(handle, 'nvmlDeviceGetBAR1MemoryInfo')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1362
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetBAR1MemoryInfo = dlsym(handle, 'nvmlDeviceGetBAR1MemoryInfo')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetIrqNum
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBAR1MemoryInfo = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetBAR1MemoryInfo);

                  /* "cuda/bindings/_internal/_nvml.pyx":1359
 *         global __nvmlDeviceGetBAR1MemoryInfo
 *         __nvmlDeviceGetBAR1MemoryInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBAR1MemoryInfo')
 *         if __nvmlDeviceGetBAR1MemoryInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1365
 * 
 *         global __nvmlDeviceGetIrqNum
 *         __nvmlDeviceGetIrqNum = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetIrqNum')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetIrqNum == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetIrqNum = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetIrqNum);

                /* "cuda/bindings/_internal/_nvml.pyx":1366
 *         global __nvmlDeviceGetIrqNum
 *         __nvmlDeviceGetIrqNum = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetIrqNum')
 *         if __nvmlDeviceGetIrqNum == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetIrqNum == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1367
 *         __nvmlDeviceGetIrqNum = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetIrqNum')
 *         if __nvmlDeviceGetIrqNum == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetIrqNum = dlsym(handle, 'nvmlDeviceGetIrqNum')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1368
 *         if __nvmlDeviceGetIrqNum == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetIrqNum = dlsym(handle, 'nvmlDeviceGetIrqNum')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1368, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1367
 *         __nvmlDeviceGetIrqNum = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetIrqNum')
 *         if __nvmlDeviceGetIrqNum == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetIrqNum = dlsym(handle, 'nvmlDeviceGetIrqNum')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1369
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetIrqNum = dlsym(handle, 'nvmlDeviceGetIrqNum')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetNumGpuCores
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetIrqNum = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetIrqNum);

                  /* "cuda/bindings/_internal/_nvml.pyx":1366
 *         global __nvmlDeviceGetIrqNum
 *         __nvmlDeviceGetIrqNum = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetIrqNum')
 *         if __nvmlDeviceGetIrqNum == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1372
 * 
 *         global __nvmlDeviceGetNumGpuCores
 *         __nvmlDeviceGetNumGpuCores = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNumGpuCores')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetNumGpuCores == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNumGpuCores = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetNumGpuCores);

                /* "cuda/bindings/_internal/_nvml.pyx":1373
 *         global __nvmlDeviceGetNumGpuCores
 *         __nvmlDeviceGetNumGpuCores = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNumGpuCores')
 *         if __nvmlDeviceGetNumGpuCores == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNumGpuCores == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1374
 *         __nvmlDeviceGetNumGpuCores = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNumGpuCores')
 *         if __nvmlDeviceGetNumGpuCores == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetNumGpuCores = dlsym(handle, 'nvmlDeviceGetNumGpuCores')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1375
 *         if __nvmlDeviceGetNumGpuCores == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetNumGpuCores = dlsym(handle, 'nvmlDeviceGetNumGpuCores')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1375, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1374
 *         __nvmlDeviceGetNumGpuCores = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNumGpuCores')
 *         if __nvmlDeviceGetNumGpuCores == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetNumGpuCores = dlsym(handle, 'nvmlDeviceGetNumGpuCores')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1376
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetNumGpuCores = dlsym(handle, 'nvmlDeviceGetNumGpuCores')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetPowerSource
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNumGpuCores = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetNumGpuCores);

                  /* "cuda/bindings/_internal/_nvml.pyx":1373
 *         global __nvmlDeviceGetNumGpuCores
 *         __nvmlDeviceGetNumGpuCores = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNumGpuCores')
 *         if __nvmlDeviceGetNumGpuCores == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1379
 * 
 *         global __nvmlDeviceGetPowerSource
 *         __nvmlDeviceGetPowerSource = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerSource')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetPowerSource == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerSource = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetPowerSource);

                /* "cuda/bindings/_internal/_nvml.pyx":1380
 *         global __nvmlDeviceGetPowerSource
 *         __nvmlDeviceGetPowerSource = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerSource')
 *         if __nvmlDeviceGetPowerSource == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerSource == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1381
 *         __nvmlDeviceGetPowerSource = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerSource')
 *         if __nvmlDeviceGetPowerSource == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPowerSource = dlsym(handle, 'nvmlDeviceGetPowerSource')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1382
 *         if __nvmlDeviceGetPowerSource == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetPowerSource = dlsym(handle, 'nvmlDeviceGetPowerSource')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1382, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1381
 *         __nvmlDeviceGetPowerSource = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerSource')
 *         if __nvmlDeviceGetPowerSource == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPowerSource = dlsym(handle, 'nvmlDeviceGetPowerSource')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1383
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetPowerSource = dlsym(handle, 'nvmlDeviceGetPowerSource')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetMemoryBusWidth
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerSource = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetPowerSource);

                  /* "cuda/bindings/_internal/_nvml.pyx":1380
 *         global __nvmlDeviceGetPowerSource
 *         __nvmlDeviceGetPowerSource = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerSource')
 *         if __nvmlDeviceGetPowerSource == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1386
 * 
 *         global __nvmlDeviceGetMemoryBusWidth
 *         __nvmlDeviceGetMemoryBusWidth = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemoryBusWidth')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetMemoryBusWidth == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryBusWidth = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetMemoryBusWidth);

                /* "cuda/bindings/_internal/_nvml.pyx":1387
 *         global __nvmlDeviceGetMemoryBusWidth
 *         __nvmlDeviceGetMemoryBusWidth = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemoryBusWidth')
 *         if __nvmlDeviceGetMemoryBusWidth == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryBusWidth == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1388
 *         __nvmlDeviceGetMemoryBusWidth = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemoryBusWidth')
 *         if __nvmlDeviceGetMemoryBusWidth == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMemoryBusWidth = dlsym(handle, 'nvmlDeviceGetMemoryBusWidth')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1389
 *         if __nvmlDeviceGetMemoryBusWidth == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetMemoryBusWidth = dlsym(handle, 'nvmlDeviceGetMemoryBusWidth')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1389, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1388
 *         __nvmlDeviceGetMemoryBusWidth = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemoryBusWidth')
 *         if __nvmlDeviceGetMemoryBusWidth == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMemoryBusWidth = dlsym(handle, 'nvmlDeviceGetMemoryBusWidth')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1390
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetMemoryBusWidth = dlsym(handle, 'nvmlDeviceGetMemoryBusWidth')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetPcieLinkMaxSpeed
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryBusWidth = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetMemoryBusWidth);

                  /* "cuda/bindings/_internal/_nvml.pyx":1387
 *         global __nvmlDeviceGetMemoryBusWidth
 *         __nvmlDeviceGetMemoryBusWidth = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMemoryBusWidth')
 *         if __nvmlDeviceGetMemoryBusWidth == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1393
 * 
 *         global __nvmlDeviceGetPcieLinkMaxSpeed
 *         __nvmlDeviceGetPcieLinkMaxSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPcieLinkMaxSpeed')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetPcieLinkMaxSpeed == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieLinkMaxSpeed = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetPcieLinkMaxSpeed);

                /* "cuda/bindings/_internal/_nvml.pyx":1394
 *         global __nvmlDeviceGetPcieLinkMaxSpeed
 *         __nvmlDeviceGetPcieLinkMaxSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPcieLinkMaxSpeed')
 *         if __nvmlDeviceGetPcieLinkMaxSpeed == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieLinkMaxSpeed == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1395
 *         __nvmlDeviceGetPcieLinkMaxSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPcieLinkMaxSpeed')
 *         if __nvmlDeviceGetPcieLinkMaxSpeed == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPcieLinkMaxSpeed = dlsym(handle, 'nvmlDeviceGetPcieLinkMaxSpeed')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1396
 *         if __nvmlDeviceGetPcieLinkMaxSpeed == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetPcieLinkMaxSpeed = dlsym(handle, 'nvmlDeviceGetPcieLinkMaxSpeed')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1396, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1395
 *         __nvmlDeviceGetPcieLinkMaxSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPcieLinkMaxSpeed')
 *         if __nvmlDeviceGetPcieLinkMaxSpeed == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPcieLinkMaxSpeed = dlsym(handle, 'nvmlDeviceGetPcieLinkMaxSpeed')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1397
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetPcieLinkMaxSpeed = dlsym(handle, 'nvmlDeviceGetPcieLinkMaxSpeed')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetPcieSpeed
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieLinkMaxSpeed = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetPcieLinkMaxSpeed);

                  /* "cuda/bindings/_internal/_nvml.pyx":1394
 *         global __nvmlDeviceGetPcieLinkMaxSpeed
 *         __nvmlDeviceGetPcieLinkMaxSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPcieLinkMaxSpeed')
 *         if __nvmlDeviceGetPcieLinkMaxSpeed == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1400
 * 
 *         global __nvmlDeviceGetPcieSpeed
 *         __nvmlDeviceGetPcieSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPcieSpeed')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetPcieSpeed == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieSpeed = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetPcieSpeed);

                /* "cuda/bindings/_internal/_nvml.pyx":1401
 *         global __nvmlDeviceGetPcieSpeed
 *         __nvmlDeviceGetPcieSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPcieSpeed')
 *         if __nvmlDeviceGetPcieSpeed == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieSpeed == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1402
 *         __nvmlDeviceGetPcieSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPcieSpeed')
 *         if __nvmlDeviceGetPcieSpeed == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPcieSpeed = dlsym(handle, 'nvmlDeviceGetPcieSpeed')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1403
 *         if __nvmlDeviceGetPcieSpeed == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetPcieSpeed = dlsym(handle, 'nvmlDeviceGetPcieSpeed')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1403, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1402
 *         __nvmlDeviceGetPcieSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPcieSpeed')
 *         if __nvmlDeviceGetPcieSpeed == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPcieSpeed = dlsym(handle, 'nvmlDeviceGetPcieSpeed')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1404
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetPcieSpeed = dlsym(handle, 'nvmlDeviceGetPcieSpeed')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetAdaptiveClockInfoStatus
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieSpeed = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetPcieSpeed);

                  /* "cuda/bindings/_internal/_nvml.pyx":1401
 *         global __nvmlDeviceGetPcieSpeed
 *         __nvmlDeviceGetPcieSpeed = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPcieSpeed')
 *         if __nvmlDeviceGetPcieSpeed == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1407
 * 
 *         global __nvmlDeviceGetAdaptiveClockInfoStatus
 *         __nvmlDeviceGetAdaptiveClockInfoStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAdaptiveClockInfoStatus')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetAdaptiveClockInfoStatus == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAdaptiveClockInfoStatus = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetAdaptiveClockInfoSt);

                /* "cuda/bindings/_internal/_nvml.pyx":1408
 *         global __nvmlDeviceGetAdaptiveClockInfoStatus
 *         __nvmlDeviceGetAdaptiveClockInfoStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAdaptiveClockInfoStatus')
 *         if __nvmlDeviceGetAdaptiveClockInfoStatus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAdaptiveClockInfoStatus == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1409
 *         __nvmlDeviceGetAdaptiveClockInfoStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAdaptiveClockInfoStatus')
 *         if __nvmlDeviceGetAdaptiveClockInfoStatus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetAdaptiveClockInfoStatus = dlsym(handle, 'nvmlDeviceGetAdaptiveClockInfoStatus')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1410
 *         if __nvmlDeviceGetAdaptiveClockInfoStatus == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetAdaptiveClockInfoStatus = dlsym(handle, 'nvmlDeviceGetAdaptiveClockInfoStatus')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1410, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1409
 *         __nvmlDeviceGetAdaptiveClockInfoStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAdaptiveClockInfoStatus')
 *         if __nvmlDeviceGetAdaptiveClockInfoStatus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetAdaptiveClockInfoStatus = dlsym(handle, 'nvmlDeviceGetAdaptiveClockInfoStatus')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1411
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetAdaptiveClockInfoStatus = dlsym(handle, 'nvmlDeviceGetAdaptiveClockInfoStatus')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetBusType
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAdaptiveClockInfoStatus = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetAdaptiveClockInfoSt);

                  /* "cuda/bindings/_internal/_nvml.pyx":1408
 *         global __nvmlDeviceGetAdaptiveClockInfoStatus
 *         __nvmlDeviceGetAdaptiveClockInfoStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAdaptiveClockInfoStatus')
 *         if __nvmlDeviceGetAdaptiveClockInfoStatus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1414
 * 
 *         global __nvmlDeviceGetBusType
 *         __nvmlDeviceGetBusType = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBusType')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetBusType == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBusType = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetBusType);

                /* "cuda/bindings/_internal/_nvml.pyx":1415
 *         global __nvmlDeviceGetBusType
 *         __nvmlDeviceGetBusType = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBusType')
 *         if __nvmlDeviceGetBusType == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBusType == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1416
 *         __nvmlDeviceGetBusType = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBusType')
 *         if __nvmlDeviceGetBusType == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetBusType = dlsym(handle, 'nvmlDeviceGetBusType')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1417
 *         if __nvmlDeviceGetBusType == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetBusType = dlsym(handle, 'nvmlDeviceGetBusType')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1417, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1416
 *         __nvmlDeviceGetBusType = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBusType')
 *         if __nvmlDeviceGetBusType == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetBusType = dlsym(handle, 'nvmlDeviceGetBusType')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1418
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetBusType = dlsym(handle, 'nvmlDeviceGetBusType')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetGpuFabricInfoV
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBusType = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetBusType);

                  /* "cuda/bindings/_internal/_nvml.pyx":1415
 *         global __nvmlDeviceGetBusType
 *         __nvmlDeviceGetBusType = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetBusType')
 *         if __nvmlDeviceGetBusType == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1421
 * 
 *         global __nvmlDeviceGetGpuFabricInfoV
 *         __nvmlDeviceGetGpuFabricInfoV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuFabricInfoV')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetGpuFabricInfoV == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuFabricInfoV = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetGpuFabricInfoV);

                /* "cuda/bindings/_internal/_nvml.pyx":1422
 *         global __nvmlDeviceGetGpuFabricInfoV
 *         __nvmlDeviceGetGpuFabricInfoV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuFabricInfoV')
 *         if __nvmlDeviceGetGpuFabricInfoV == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuFabricInfoV == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1423
 *         __nvmlDeviceGetGpuFabricInfoV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuFabricInfoV')
 *         if __nvmlDeviceGetGpuFabricInfoV == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuFabricInfoV = dlsym(handle, 'nvmlDeviceGetGpuFabricInfoV')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1424
 *         if __nvmlDeviceGetGpuFabricInfoV == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetGpuFabricInfoV = dlsym(handle, 'nvmlDeviceGetGpuFabricInfoV')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1424, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1423
 *         __nvmlDeviceGetGpuFabricInfoV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuFabricInfoV')
 *         if __nvmlDeviceGetGpuFabricInfoV == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuFabricInfoV = dlsym(handle, 'nvmlDeviceGetGpuFabricInfoV')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1425
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuFabricInfoV = dlsym(handle, 'nvmlDeviceGetGpuFabricInfoV')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlSystemGetConfComputeCapabilities
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuFabricInfoV = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetGpuFabricInfoV);

                  /* "cuda/bindings/_internal/_nvml.pyx":1422
 *         global __nvmlDeviceGetGpuFabricInfoV
 *         __nvmlDeviceGetGpuFabricInfoV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuFabricInfoV')
 *         if __nvmlDeviceGetGpuFabricInfoV == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1428
 * 
 *         global __nvmlSystemGetConfComputeCapabilities
 *         __nvmlSystemGetConfComputeCapabilities = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeCapabilities')             # <<<<<<<<<<<<<<
 *         if __nvmlSystemGetConfComputeCapabilities == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeCapabilities = dlsym(RTLD_DEFAULT, __pyx_k_nvmlSystemGetConfComputeCapabili);

                /* "cuda/bindings/_internal/_nvml.pyx":1429
 *         global __nvmlSystemGetConfComputeCapabilities
 *         __nvmlSystemGetConfComputeCapabilities = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeCapabilities')
 *         if __nvmlSystemGetConfComputeCapabilities == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeCapabilities == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1430
 *         __nvmlSystemGetConfComputeCapabilities = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeCapabilities')
 *         if __nvmlSystemGetConfComputeCapabilities == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetConfComputeCapabilities = dlsym(handle, 'nvmlSystemGetConfComputeCapabilities')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1431
 *         if __nvmlSystemGetConfComputeCapabilities == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlSystemGetConfComputeCapabilities = dlsym(handle, 'nvmlSystemGetConfComputeCapabilities')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1431, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1430
 *         __nvmlSystemGetConfComputeCapabilities = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeCapabilities')
 *         if __nvmlSystemGetConfComputeCapabilities == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetConfComputeCapabilities = dlsym(handle, 'nvmlSystemGetConfComputeCapabilities')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1432
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlSystemGetConfComputeCapabilities = dlsym(handle, 'nvmlSystemGetConfComputeCapabilities')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlSystemGetConfComputeState
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeCapabilities = dlsym(__pyx_v_handle, __pyx_k_nvmlSystemGetConfComputeCapabili);

                  /* "cuda/bindings/_internal/_nvml.pyx":1429
 *         global __nvmlSystemGetConfComputeCapabilities
 *         __nvmlSystemGetConfComputeCapabilities = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeCapabilities')
 *         if __nvmlSystemGetConfComputeCapabilities == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1435
 * 
 *         global __nvmlSystemGetConfComputeState
 *         __nvmlSystemGetConfComputeState = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeState')             # <<<<<<<<<<<<<<
 *         if __nvmlSystemGetConfComputeState == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeState = dlsym(RTLD_DEFAULT, __pyx_k_nvmlSystemGetConfComputeState);

                /* "cuda/bindings/_internal/_nvml.pyx":1436
 *         global __nvmlSystemGetConfComputeState
 *         __nvmlSystemGetConfComputeState = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeState')
 *         if __nvmlSystemGetConfComputeState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeState == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1437
 *         __nvmlSystemGetConfComputeState = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeState')
 *         if __nvmlSystemGetConfComputeState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetConfComputeState = dlsym(handle, 'nvmlSystemGetConfComputeState')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1438
 *         if __nvmlSystemGetConfComputeState == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlSystemGetConfComputeState = dlsym(handle, 'nvmlSystemGetConfComputeState')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1438, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1437
 *         __nvmlSystemGetConfComputeState = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeState')
 *         if __nvmlSystemGetConfComputeState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetConfComputeState = dlsym(handle, 'nvmlSystemGetConfComputeState')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1439
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlSystemGetConfComputeState = dlsym(handle, 'nvmlSystemGetConfComputeState')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetConfComputeMemSizeInfo
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeState = dlsym(__pyx_v_handle, __pyx_k_nvmlSystemGetConfComputeState);

                  /* "cuda/bindings/_internal/_nvml.pyx":1436
 *         global __nvmlSystemGetConfComputeState
 *         __nvmlSystemGetConfComputeState = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeState')
 *         if __nvmlSystemGetConfComputeState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1442
 * 
 *         global __nvmlDeviceGetConfComputeMemSizeInfo
 *         __nvmlDeviceGetConfComputeMemSizeInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetConfComputeMemSizeInfo')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetConfComputeMemSizeInfo == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeMemSizeInfo = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetConfComputeMemSizeI);

                /* "cuda/bindings/_internal/_nvml.pyx":1443
 *         global __nvmlDeviceGetConfComputeMemSizeInfo
 *         __nvmlDeviceGetConfComputeMemSizeInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetConfComputeMemSizeInfo')
 *         if __nvmlDeviceGetConfComputeMemSizeInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeMemSizeInfo == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1444
 *         __nvmlDeviceGetConfComputeMemSizeInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetConfComputeMemSizeInfo')
 *         if __nvmlDeviceGetConfComputeMemSizeInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetConfComputeMemSizeInfo = dlsym(handle, 'nvmlDeviceGetConfComputeMemSizeInfo')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1445
 *         if __nvmlDeviceGetConfComputeMemSizeInfo == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetConfComputeMemSizeInfo = dlsym(handle, 'nvmlDeviceGetConfComputeMemSizeInfo')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1445, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1444
 *         __nvmlDeviceGetConfComputeMemSizeInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetConfComputeMemSizeInfo')
 *         if __nvmlDeviceGetConfComputeMemSizeInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetConfComputeMemSizeInfo = dlsym(handle, 'nvmlDeviceGetConfComputeMemSizeInfo')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1446
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetConfComputeMemSizeInfo = dlsym(handle, 'nvmlDeviceGetConfComputeMemSizeInfo')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlSystemGetConfComputeGpusReadyState
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeMemSizeInfo = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetConfComputeMemSizeI);

                  /* "cuda/bindings/_internal/_nvml.pyx":1443
 *         global __nvmlDeviceGetConfComputeMemSizeInfo
 *         __nvmlDeviceGetConfComputeMemSizeInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetConfComputeMemSizeInfo')
 *         if __nvmlDeviceGetConfComputeMemSizeInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1449
 * 
 *         global __nvmlSystemGetConfComputeGpusReadyState
 *         __nvmlSystemGetConfComputeGpusReadyState = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeGpusReadyState')             # <<<<<<<<<<<<<<
 *         if __nvmlSystemGetConfComputeGpusReadyState == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeGpusReadyState = dlsym(RTLD_DEFAULT, __pyx_k_nvmlSystemGetConfComputeGpusRead);

                /* "cuda/bindings/_internal/_nvml.pyx":1450
 *         global __nvmlSystemGetConfComputeGpusReadyState
 *         __nvmlSystemGetConfComputeGpusReadyState = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeGpusReadyState')
 *         if __nvmlSystemGetConfComputeGpusReadyState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeGpusReadyState == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1451
 *         __nvmlSystemGetConfComputeGpusReadyState = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeGpusReadyState')
 *         if __nvmlSystemGetConfComputeGpusReadyState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetConfComputeGpusReadyState = dlsym(handle, 'nvmlSystemGetConfComputeGpusReadyState')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1452
 *         if __nvmlSystemGetConfComputeGpusReadyState == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlSystemGetConfComputeGpusReadyState = dlsym(handle, 'nvmlSystemGetConfComputeGpusReadyState')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1452, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1451
 *         __nvmlSystemGetConfComputeGpusReadyState = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeGpusReadyState')
 *         if __nvmlSystemGetConfComputeGpusReadyState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetConfComputeGpusReadyState = dlsym(handle, 'nvmlSystemGetConfComputeGpusReadyState')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1453
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlSystemGetConfComputeGpusReadyState = dlsym(handle, 'nvmlSystemGetConfComputeGpusReadyState')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetConfComputeProtectedMemoryUsage
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeGpusReadyState = dlsym(__pyx_v_handle, __pyx_k_nvmlSystemGetConfComputeGpusRead);

                  /* "cuda/bindings/_internal/_nvml.pyx":1450
 *         global __nvmlSystemGetConfComputeGpusReadyState
 *         __nvmlSystemGetConfComputeGpusReadyState = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeGpusReadyState')
 *         if __nvmlSystemGetConfComputeGpusReadyState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1456
 * 
 *         global __nvmlDeviceGetConfComputeProtectedMemoryUsage
 *         __nvmlDeviceGetConfComputeProtectedMemoryUsage = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetConfComputeProtectedMemoryUsage')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetConfComputeProtectedMemoryUsage == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeProtectedMemoryUsage = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetConfComputeProtecte);

                /* "cuda/bindings/_internal/_nvml.pyx":1457
 *         global __nvmlDeviceGetConfComputeProtectedMemoryUsage
 *         __nvmlDeviceGetConfComputeProtectedMemoryUsage = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetConfComputeProtectedMemoryUsage')
 *         if __nvmlDeviceGetConfComputeProtectedMemoryUsage == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeProtectedMemoryUsage == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1458
 *         __nvmlDeviceGetConfComputeProtectedMemoryUsage = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetConfComputeProtectedMemoryUsage')
 *         if __nvmlDeviceGetConfComputeProtectedMemoryUsage == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetConfComputeProtectedMemoryUsage = dlsym(handle, 'nvmlDeviceGetConfComputeProtectedMemoryUsage')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1459
 *         if __nvmlDeviceGetConfComputeProtectedMemoryUsage == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetConfComputeProtectedMemoryUsage = dlsym(handle, 'nvmlDeviceGetConfComputeProtectedMemoryUsage')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1459, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1458
 *         __nvmlDeviceGetConfComputeProtectedMemoryUsage = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetConfComputeProtectedMemoryUsage')
 *         if __nvmlDeviceGetConfComputeProtectedMemoryUsage == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetConfComputeProtectedMemoryUsage = dlsym(handle, 'nvmlDeviceGetConfComputeProtectedMemoryUsage')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1460
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetConfComputeProtectedMemoryUsage = dlsym(handle, 'nvmlDeviceGetConfComputeProtectedMemoryUsage')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetConfComputeGpuCertificate
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeProtectedMemoryUsage = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetConfComputeProtecte);

                  /* "cuda/bindings/_internal/_nvml.pyx":1457
 *         global __nvmlDeviceGetConfComputeProtectedMemoryUsage
 *         __nvmlDeviceGetConfComputeProtectedMemoryUsage = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetConfComputeProtectedMemoryUsage')
 *         if __nvmlDeviceGetConfComputeProtectedMemoryUsage == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1463
 * 
 *         global __nvmlDeviceGetConfComputeGpuCertificate
 *         __nvmlDeviceGetConfComputeGpuCertificate = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetConfComputeGpuCertificate')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetConfComputeGpuCertificate == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeGpuCertificate = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetConfComputeGpuCerti);

                /* "cuda/bindings/_internal/_nvml.pyx":1464
 *         global __nvmlDeviceGetConfComputeGpuCertificate
 *         __nvmlDeviceGetConfComputeGpuCertificate = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetConfComputeGpuCertificate')
 *         if __nvmlDeviceGetConfComputeGpuCertificate == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeGpuCertificate == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1465
 *         __nvmlDeviceGetConfComputeGpuCertificate = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetConfComputeGpuCertificate')
 *         if __nvmlDeviceGetConfComputeGpuCertificate == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetConfComputeGpuCertificate = dlsym(handle, 'nvmlDeviceGetConfComputeGpuCertificate')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1466
 *         if __nvmlDeviceGetConfComputeGpuCertificate == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetConfComputeGpuCertificate = dlsym(handle, 'nvmlDeviceGetConfComputeGpuCertificate')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1466, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1465
 *         __nvmlDeviceGetConfComputeGpuCertificate = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetConfComputeGpuCertificate')
 *         if __nvmlDeviceGetConfComputeGpuCertificate == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetConfComputeGpuCertificate = dlsym(handle, 'nvmlDeviceGetConfComputeGpuCertificate')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1467
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetConfComputeGpuCertificate = dlsym(handle, 'nvmlDeviceGetConfComputeGpuCertificate')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetConfComputeGpuAttestationReport
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeGpuCertificate = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetConfComputeGpuCerti);

                  /* "cuda/bindings/_internal/_nvml.pyx":1464
 *         global __nvmlDeviceGetConfComputeGpuCertificate
 *         __nvmlDeviceGetConfComputeGpuCertificate = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetConfComputeGpuCertificate')
 *         if __nvmlDeviceGetConfComputeGpuCertificate == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1470
 * 
 *         global __nvmlDeviceGetConfComputeGpuAttestationReport
 *         __nvmlDeviceGetConfComputeGpuAttestationReport = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetConfComputeGpuAttestationReport')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetConfComputeGpuAttestationReport == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeGpuAttestationReport = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetConfComputeGpuAttes);

                /* "cuda/bindings/_internal/_nvml.pyx":1471
 *         global __nvmlDeviceGetConfComputeGpuAttestationReport
 *         __nvmlDeviceGetConfComputeGpuAttestationReport = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetConfComputeGpuAttestationReport')
 *         if __nvmlDeviceGetConfComputeGpuAttestationReport == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeGpuAttestationReport == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1472
 *         __nvmlDeviceGetConfComputeGpuAttestationReport = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetConfComputeGpuAttestationReport')
 *         if __nvmlDeviceGetConfComputeGpuAttestationReport == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetConfComputeGpuAttestationReport = dlsym(handle, 'nvmlDeviceGetConfComputeGpuAttestationReport')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1473
 *         if __nvmlDeviceGetConfComputeGpuAttestationReport == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetConfComputeGpuAttestationReport = dlsym(handle, 'nvmlDeviceGetConfComputeGpuAttestationReport')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1473, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1472
 *         __nvmlDeviceGetConfComputeGpuAttestationReport = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetConfComputeGpuAttestationReport')
 *         if __nvmlDeviceGetConfComputeGpuAttestationReport == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetConfComputeGpuAttestationReport = dlsym(handle, 'nvmlDeviceGetConfComputeGpuAttestationReport')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1474
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetConfComputeGpuAttestationReport = dlsym(handle, 'nvmlDeviceGetConfComputeGpuAttestationReport')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlSystemGetConfComputeKeyRotationThresholdInfo
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeGpuAttestationReport = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetConfComputeGpuAttes);

                  /* "cuda/bindings/_internal/_nvml.pyx":1471
 *         global __nvmlDeviceGetConfComputeGpuAttestationReport
 *         __nvmlDeviceGetConfComputeGpuAttestationReport = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetConfComputeGpuAttestationReport')
 *         if __nvmlDeviceGetConfComputeGpuAttestationReport == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1477
 * 
 *         global __nvmlSystemGetConfComputeKeyRotationThresholdInfo
 *         __nvmlSystemGetConfComputeKeyRotationThresholdInfo = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeKeyRotationThresholdInfo')             # <<<<<<<<<<<<<<
 *         if __nvmlSystemGetConfComputeKeyRotationThresholdInfo == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeKeyRotationThresholdInfo = dlsym(RTLD_DEFAULT, __pyx_k_nvmlSystemGetConfComputeKeyRotat);

                /* "cuda/bindings/_internal/_nvml.pyx":1478
 *         global __nvmlSystemGetConfComputeKeyRotationThresholdInfo
 *         __nvmlSystemGetConfComputeKeyRotationThresholdInfo = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeKeyRotationThresholdInfo')
 *         if __nvmlSystemGetConfComputeKeyRotationThresholdInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeKeyRotationThresholdInfo == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1479
 *         __nvmlSystemGetConfComputeKeyRotationThresholdInfo = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeKeyRotationThresholdInfo')
 *         if __nvmlSystemGetConfComputeKeyRotationThresholdInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetConfComputeKeyRotationThresholdInfo = dlsym(handle, 'nvmlSystemGetConfComputeKeyRotationThresholdInfo')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1480
 *         if __nvmlSystemGetConfComputeKeyRotationThresholdInfo == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlSystemGetConfComputeKeyRotationThresholdInfo = dlsym(handle, 'nvmlSystemGetConfComputeKeyRotationThresholdInfo')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1480, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1479
 *         __nvmlSystemGetConfComputeKeyRotationThresholdInfo = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeKeyRotationThresholdInfo')
 *         if __nvmlSystemGetConfComputeKeyRotationThresholdInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetConfComputeKeyRotationThresholdInfo = dlsym(handle, 'nvmlSystemGetConfComputeKeyRotationThresholdInfo')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1481
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlSystemGetConfComputeKeyRotationThresholdInfo = dlsym(handle, 'nvmlSystemGetConfComputeKeyRotationThresholdInfo')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetConfComputeUnprotectedMemSize
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeKeyRotationThresholdInfo = dlsym(__pyx_v_handle, __pyx_k_nvmlSystemGetConfComputeKeyRotat);

                  /* "cuda/bindings/_internal/_nvml.pyx":1478
 *         global __nvmlSystemGetConfComputeKeyRotationThresholdInfo
 *         __nvmlSystemGetConfComputeKeyRotationThresholdInfo = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeKeyRotationThresholdInfo')
 *         if __nvmlSystemGetConfComputeKeyRotationThresholdInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1484
 * 
 *         global __nvmlDeviceSetConfComputeUnprotectedMemSize
 *         __nvmlDeviceSetConfComputeUnprotectedMemSize = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetConfComputeUnprotectedMemSize')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetConfComputeUnprotectedMemSize == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetConfComputeUnprotectedMemSize = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetConfComputeUnprotec);

                /* "cuda/bindings/_internal/_nvml.pyx":1485
 *         global __nvmlDeviceSetConfComputeUnprotectedMemSize
 *         __nvmlDeviceSetConfComputeUnprotectedMemSize = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetConfComputeUnprotectedMemSize')
 *         if __nvmlDeviceSetConfComputeUnprotectedMemSize == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetConfComputeUnprotectedMemSize == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1486
 *         __nvmlDeviceSetConfComputeUnprotectedMemSize = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetConfComputeUnprotectedMemSize')
 *         if __nvmlDeviceSetConfComputeUnprotectedMemSize == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetConfComputeUnprotectedMemSize = dlsym(handle, 'nvmlDeviceSetConfComputeUnprotectedMemSize')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1487
 *         if __nvmlDeviceSetConfComputeUnprotectedMemSize == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetConfComputeUnprotectedMemSize = dlsym(handle, 'nvmlDeviceSetConfComputeUnprotectedMemSize')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1487, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1486
 *         __nvmlDeviceSetConfComputeUnprotectedMemSize = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetConfComputeUnprotectedMemSize')
 *         if __nvmlDeviceSetConfComputeUnprotectedMemSize == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetConfComputeUnprotectedMemSize = dlsym(handle, 'nvmlDeviceSetConfComputeUnprotectedMemSize')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1488
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetConfComputeUnprotectedMemSize = dlsym(handle, 'nvmlDeviceSetConfComputeUnprotectedMemSize')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlSystemSetConfComputeGpusReadyState
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetConfComputeUnprotectedMemSize = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetConfComputeUnprotec);

                  /* "cuda/bindings/_internal/_nvml.pyx":1485
 *         global __nvmlDeviceSetConfComputeUnprotectedMemSize
 *         __nvmlDeviceSetConfComputeUnprotectedMemSize = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetConfComputeUnprotectedMemSize')
 *         if __nvmlDeviceSetConfComputeUnprotectedMemSize == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1491
 * 
 *         global __nvmlSystemSetConfComputeGpusReadyState
 *         __nvmlSystemSetConfComputeGpusReadyState = dlsym(RTLD_DEFAULT, 'nvmlSystemSetConfComputeGpusReadyState')             # <<<<<<<<<<<<<<
 *         if __nvmlSystemSetConfComputeGpusReadyState == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemSetConfComputeGpusReadyState = dlsym(RTLD_DEFAULT, __pyx_k_nvmlSystemSetConfComputeGpusRead);

                /* "cuda/bindings/_internal/_nvml.pyx":1492
 *         global __nvmlSystemSetConfComputeGpusReadyState
 *         __nvmlSystemSetConfComputeGpusReadyState = dlsym(RTLD_DEFAULT, 'nvmlSystemSetConfComputeGpusReadyState')
 *         if __nvmlSystemSetConfComputeGpusReadyState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemSetConfComputeGpusReadyState == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1493
 *         __nvmlSystemSetConfComputeGpusReadyState = dlsym(RTLD_DEFAULT, 'nvmlSystemSetConfComputeGpusReadyState')
 *         if __nvmlSystemSetConfComputeGpusReadyState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemSetConfComputeGpusReadyState = dlsym(handle, 'nvmlSystemSetConfComputeGpusReadyState')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1494
 *         if __nvmlSystemSetConfComputeGpusReadyState == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlSystemSetConfComputeGpusReadyState = dlsym(handle, 'nvmlSystemSetConfComputeGpusReadyState')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1494, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1493
 *         __nvmlSystemSetConfComputeGpusReadyState = dlsym(RTLD_DEFAULT, 'nvmlSystemSetConfComputeGpusReadyState')
 *         if __nvmlSystemSetConfComputeGpusReadyState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemSetConfComputeGpusReadyState = dlsym(handle, 'nvmlSystemSetConfComputeGpusReadyState')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1495
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlSystemSetConfComputeGpusReadyState = dlsym(handle, 'nvmlSystemSetConfComputeGpusReadyState')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlSystemSetConfComputeKeyRotationThresholdInfo
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemSetConfComputeGpusReadyState = dlsym(__pyx_v_handle, __pyx_k_nvmlSystemSetConfComputeGpusRead);

                  /* "cuda/bindings/_internal/_nvml.pyx":1492
 *         global __nvmlSystemSetConfComputeGpusReadyState
 *         __nvmlSystemSetConfComputeGpusReadyState = dlsym(RTLD_DEFAULT, 'nvmlSystemSetConfComputeGpusReadyState')
 *         if __nvmlSystemSetConfComputeGpusReadyState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1498
 * 
 *         global __nvmlSystemSetConfComputeKeyRotationThresholdInfo
 *         __nvmlSystemSetConfComputeKeyRotationThresholdInfo = dlsym(RTLD_DEFAULT, 'nvmlSystemSetConfComputeKeyRotationThresholdInfo')             # <<<<<<<<<<<<<<
 *         if __nvmlSystemSetConfComputeKeyRotationThresholdInfo == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemSetConfComputeKeyRotationThresholdInfo = dlsym(RTLD_DEFAULT, __pyx_k_nvmlSystemSetConfComputeKeyRotat);

                /* "cuda/bindings/_internal/_nvml.pyx":1499
 *         global __nvmlSystemSetConfComputeKeyRotationThresholdInfo
 *         __nvmlSystemSetConfComputeKeyRotationThresholdInfo = dlsym(RTLD_DEFAULT, 'nvmlSystemSetConfComputeKeyRotationThresholdInfo')
 *         if __nvmlSystemSetConfComputeKeyRotationThresholdInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemSetConfComputeKeyRotationThresholdInfo == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1500
 *         __nvmlSystemSetConfComputeKeyRotationThresholdInfo = dlsym(RTLD_DEFAULT, 'nvmlSystemSetConfComputeKeyRotationThresholdInfo')
 *         if __nvmlSystemSetConfComputeKeyRotationThresholdInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemSetConfComputeKeyRotationThresholdInfo = dlsym(handle, 'nvmlSystemSetConfComputeKeyRotationThresholdInfo')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1501
 *         if __nvmlSystemSetConfComputeKeyRotationThresholdInfo == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlSystemSetConfComputeKeyRotationThresholdInfo = dlsym(handle, 'nvmlSystemSetConfComputeKeyRotationThresholdInfo')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1501, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1500
 *         __nvmlSystemSetConfComputeKeyRotationThresholdInfo = dlsym(RTLD_DEFAULT, 'nvmlSystemSetConfComputeKeyRotationThresholdInfo')
 *         if __nvmlSystemSetConfComputeKeyRotationThresholdInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemSetConfComputeKeyRotationThresholdInfo = dlsym(handle, 'nvmlSystemSetConfComputeKeyRotationThresholdInfo')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1502
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlSystemSetConfComputeKeyRotationThresholdInfo = dlsym(handle, 'nvmlSystemSetConfComputeKeyRotationThresholdInfo')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlSystemGetConfComputeSettings
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemSetConfComputeKeyRotationThresholdInfo = dlsym(__pyx_v_handle, __pyx_k_nvmlSystemSetConfComputeKeyRotat);

                  /* "cuda/bindings/_internal/_nvml.pyx":1499
 *         global __nvmlSystemSetConfComputeKeyRotationThresholdInfo
 *         __nvmlSystemSetConfComputeKeyRotationThresholdInfo = dlsym(RTLD_DEFAULT, 'nvmlSystemSetConfComputeKeyRotationThresholdInfo')
 *         if __nvmlSystemSetConfComputeKeyRotationThresholdInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1505
 * 
 *         global __nvmlSystemGetConfComputeSettings
 *         __nvmlSystemGetConfComputeSettings = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeSettings')             # <<<<<<<<<<<<<<
 *         if __nvmlSystemGetConfComputeSettings == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeSettings = dlsym(RTLD_DEFAULT, __pyx_k_nvmlSystemGetConfComputeSettings);

                /* "cuda/bindings/_internal/_nvml.pyx":1506
 *         global __nvmlSystemGetConfComputeSettings
 *         __nvmlSystemGetConfComputeSettings = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeSettings')
 *         if __nvmlSystemGetConfComputeSettings == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeSettings == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1507
 *         __nvmlSystemGetConfComputeSettings = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeSettings')
 *         if __nvmlSystemGetConfComputeSettings == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetConfComputeSettings = dlsym(handle, 'nvmlSystemGetConfComputeSettings')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1508
 *         if __nvmlSystemGetConfComputeSettings == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlSystemGetConfComputeSettings = dlsym(handle, 'nvmlSystemGetConfComputeSettings')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1508, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1507
 *         __nvmlSystemGetConfComputeSettings = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeSettings')
 *         if __nvmlSystemGetConfComputeSettings == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetConfComputeSettings = dlsym(handle, 'nvmlSystemGetConfComputeSettings')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1509
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlSystemGetConfComputeSettings = dlsym(handle, 'nvmlSystemGetConfComputeSettings')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetGspFirmwareVersion
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeSettings = dlsym(__pyx_v_handle, __pyx_k_nvmlSystemGetConfComputeSettings);

                  /* "cuda/bindings/_internal/_nvml.pyx":1506
 *         global __nvmlSystemGetConfComputeSettings
 *         __nvmlSystemGetConfComputeSettings = dlsym(RTLD_DEFAULT, 'nvmlSystemGetConfComputeSettings')
 *         if __nvmlSystemGetConfComputeSettings == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1512
 * 
 *         global __nvmlDeviceGetGspFirmwareVersion
 *         __nvmlDeviceGetGspFirmwareVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGspFirmwareVersion')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetGspFirmwareVersion == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGspFirmwareVersion = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetGspFirmwareVersion);

                /* "cuda/bindings/_internal/_nvml.pyx":1513
 *         global __nvmlDeviceGetGspFirmwareVersion
 *         __nvmlDeviceGetGspFirmwareVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGspFirmwareVersion')
 *         if __nvmlDeviceGetGspFirmwareVersion == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGspFirmwareVersion == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1514
 *         __nvmlDeviceGetGspFirmwareVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGspFirmwareVersion')
 *         if __nvmlDeviceGetGspFirmwareVersion == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGspFirmwareVersion = dlsym(handle, 'nvmlDeviceGetGspFirmwareVersion')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1515
 *         if __nvmlDeviceGetGspFirmwareVersion == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetGspFirmwareVersion = dlsym(handle, 'nvmlDeviceGetGspFirmwareVersion')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1515, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1514
 *         __nvmlDeviceGetGspFirmwareVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGspFirmwareVersion')
 *         if __nvmlDeviceGetGspFirmwareVersion == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGspFirmwareVersion = dlsym(handle, 'nvmlDeviceGetGspFirmwareVersion')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1516
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetGspFirmwareVersion = dlsym(handle, 'nvmlDeviceGetGspFirmwareVersion')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetGspFirmwareMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGspFirmwareVersion = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetGspFirmwareVersion);

                  /* "cuda/bindings/_internal/_nvml.pyx":1513
 *         global __nvmlDeviceGetGspFirmwareVersion
 *         __nvmlDeviceGetGspFirmwareVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGspFirmwareVersion')
 *         if __nvmlDeviceGetGspFirmwareVersion == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1519
 * 
 *         global __nvmlDeviceGetGspFirmwareMode
 *         __nvmlDeviceGetGspFirmwareMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGspFirmwareMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetGspFirmwareMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGspFirmwareMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetGspFirmwareMode);

                /* "cuda/bindings/_internal/_nvml.pyx":1520
 *         global __nvmlDeviceGetGspFirmwareMode
 *         __nvmlDeviceGetGspFirmwareMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGspFirmwareMode')
 *         if __nvmlDeviceGetGspFirmwareMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGspFirmwareMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1521
 *         __nvmlDeviceGetGspFirmwareMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGspFirmwareMode')
 *         if __nvmlDeviceGetGspFirmwareMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGspFirmwareMode = dlsym(handle, 'nvmlDeviceGetGspFirmwareMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1522
 *         if __nvmlDeviceGetGspFirmwareMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetGspFirmwareMode = dlsym(handle, 'nvmlDeviceGetGspFirmwareMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1522, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1521
 *         __nvmlDeviceGetGspFirmwareMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGspFirmwareMode')
 *         if __nvmlDeviceGetGspFirmwareMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGspFirmwareMode = dlsym(handle, 'nvmlDeviceGetGspFirmwareMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1523
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetGspFirmwareMode = dlsym(handle, 'nvmlDeviceGetGspFirmwareMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetSramEccErrorStatus
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGspFirmwareMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetGspFirmwareMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":1520
 *         global __nvmlDeviceGetGspFirmwareMode
 *         __nvmlDeviceGetGspFirmwareMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGspFirmwareMode')
 *         if __nvmlDeviceGetGspFirmwareMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1526
 * 
 *         global __nvmlDeviceGetSramEccErrorStatus
 *         __nvmlDeviceGetSramEccErrorStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSramEccErrorStatus')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetSramEccErrorStatus == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSramEccErrorStatus = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetSramEccErrorStatus);

                /* "cuda/bindings/_internal/_nvml.pyx":1527
 *         global __nvmlDeviceGetSramEccErrorStatus
 *         __nvmlDeviceGetSramEccErrorStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSramEccErrorStatus')
 *         if __nvmlDeviceGetSramEccErrorStatus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSramEccErrorStatus == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1528
 *         __nvmlDeviceGetSramEccErrorStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSramEccErrorStatus')
 *         if __nvmlDeviceGetSramEccErrorStatus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetSramEccErrorStatus = dlsym(handle, 'nvmlDeviceGetSramEccErrorStatus')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1529
 *         if __nvmlDeviceGetSramEccErrorStatus == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetSramEccErrorStatus = dlsym(handle, 'nvmlDeviceGetSramEccErrorStatus')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1529, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1528
 *         __nvmlDeviceGetSramEccErrorStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSramEccErrorStatus')
 *         if __nvmlDeviceGetSramEccErrorStatus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetSramEccErrorStatus = dlsym(handle, 'nvmlDeviceGetSramEccErrorStatus')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1530
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetSramEccErrorStatus = dlsym(handle, 'nvmlDeviceGetSramEccErrorStatus')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetAccountingMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSramEccErrorStatus = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetSramEccErrorStatus);

                  /* "cuda/bindings/_internal/_nvml.pyx":1527
 *         global __nvmlDeviceGetSramEccErrorStatus
 *         __nvmlDeviceGetSramEccErrorStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSramEccErrorStatus')
 *         if __nvmlDeviceGetSramEccErrorStatus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1533
 * 
 *         global __nvmlDeviceGetAccountingMode
 *         __nvmlDeviceGetAccountingMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAccountingMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetAccountingMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetAccountingMode);

                /* "cuda/bindings/_internal/_nvml.pyx":1534
 *         global __nvmlDeviceGetAccountingMode
 *         __nvmlDeviceGetAccountingMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAccountingMode')
 *         if __nvmlDeviceGetAccountingMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1535
 *         __nvmlDeviceGetAccountingMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAccountingMode')
 *         if __nvmlDeviceGetAccountingMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetAccountingMode = dlsym(handle, 'nvmlDeviceGetAccountingMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1536
 *         if __nvmlDeviceGetAccountingMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetAccountingMode = dlsym(handle, 'nvmlDeviceGetAccountingMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1536, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1535
 *         __nvmlDeviceGetAccountingMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAccountingMode')
 *         if __nvmlDeviceGetAccountingMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetAccountingMode = dlsym(handle, 'nvmlDeviceGetAccountingMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1537
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetAccountingMode = dlsym(handle, 'nvmlDeviceGetAccountingMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetAccountingStats
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetAccountingMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":1534
 *         global __nvmlDeviceGetAccountingMode
 *         __nvmlDeviceGetAccountingMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAccountingMode')
 *         if __nvmlDeviceGetAccountingMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1540
 * 
 *         global __nvmlDeviceGetAccountingStats
 *         __nvmlDeviceGetAccountingStats = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAccountingStats')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetAccountingStats == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingStats = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetAccountingStats);

                /* "cuda/bindings/_internal/_nvml.pyx":1541
 *         global __nvmlDeviceGetAccountingStats
 *         __nvmlDeviceGetAccountingStats = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAccountingStats')
 *         if __nvmlDeviceGetAccountingStats == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingStats == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1542
 *         __nvmlDeviceGetAccountingStats = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAccountingStats')
 *         if __nvmlDeviceGetAccountingStats == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetAccountingStats = dlsym(handle, 'nvmlDeviceGetAccountingStats')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1543
 *         if __nvmlDeviceGetAccountingStats == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetAccountingStats = dlsym(handle, 'nvmlDeviceGetAccountingStats')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1543, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1542
 *         __nvmlDeviceGetAccountingStats = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAccountingStats')
 *         if __nvmlDeviceGetAccountingStats == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetAccountingStats = dlsym(handle, 'nvmlDeviceGetAccountingStats')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1544
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetAccountingStats = dlsym(handle, 'nvmlDeviceGetAccountingStats')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetAccountingPids
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingStats = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetAccountingStats);

                  /* "cuda/bindings/_internal/_nvml.pyx":1541
 *         global __nvmlDeviceGetAccountingStats
 *         __nvmlDeviceGetAccountingStats = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAccountingStats')
 *         if __nvmlDeviceGetAccountingStats == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1547
 * 
 *         global __nvmlDeviceGetAccountingPids
 *         __nvmlDeviceGetAccountingPids = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAccountingPids')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetAccountingPids == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingPids = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetAccountingPids);

                /* "cuda/bindings/_internal/_nvml.pyx":1548
 *         global __nvmlDeviceGetAccountingPids
 *         __nvmlDeviceGetAccountingPids = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAccountingPids')
 *         if __nvmlDeviceGetAccountingPids == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingPids == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1549
 *         __nvmlDeviceGetAccountingPids = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAccountingPids')
 *         if __nvmlDeviceGetAccountingPids == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetAccountingPids = dlsym(handle, 'nvmlDeviceGetAccountingPids')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1550
 *         if __nvmlDeviceGetAccountingPids == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetAccountingPids = dlsym(handle, 'nvmlDeviceGetAccountingPids')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1550, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1549
 *         __nvmlDeviceGetAccountingPids = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAccountingPids')
 *         if __nvmlDeviceGetAccountingPids == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetAccountingPids = dlsym(handle, 'nvmlDeviceGetAccountingPids')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1551
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetAccountingPids = dlsym(handle, 'nvmlDeviceGetAccountingPids')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetAccountingBufferSize
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingPids = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetAccountingPids);

                  /* "cuda/bindings/_internal/_nvml.pyx":1548
 *         global __nvmlDeviceGetAccountingPids
 *         __nvmlDeviceGetAccountingPids = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAccountingPids')
 *         if __nvmlDeviceGetAccountingPids == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1554
 * 
 *         global __nvmlDeviceGetAccountingBufferSize
 *         __nvmlDeviceGetAccountingBufferSize = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAccountingBufferSize')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetAccountingBufferSize == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingBufferSize = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetAccountingBufferSiz);

                /* "cuda/bindings/_internal/_nvml.pyx":1555
 *         global __nvmlDeviceGetAccountingBufferSize
 *         __nvmlDeviceGetAccountingBufferSize = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAccountingBufferSize')
 *         if __nvmlDeviceGetAccountingBufferSize == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingBufferSize == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1556
 *         __nvmlDeviceGetAccountingBufferSize = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAccountingBufferSize')
 *         if __nvmlDeviceGetAccountingBufferSize == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetAccountingBufferSize = dlsym(handle, 'nvmlDeviceGetAccountingBufferSize')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1557
 *         if __nvmlDeviceGetAccountingBufferSize == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetAccountingBufferSize = dlsym(handle, 'nvmlDeviceGetAccountingBufferSize')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1557, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1556
 *         __nvmlDeviceGetAccountingBufferSize = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAccountingBufferSize')
 *         if __nvmlDeviceGetAccountingBufferSize == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetAccountingBufferSize = dlsym(handle, 'nvmlDeviceGetAccountingBufferSize')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1558
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetAccountingBufferSize = dlsym(handle, 'nvmlDeviceGetAccountingBufferSize')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetRetiredPages
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingBufferSize = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetAccountingBufferSiz);

                  /* "cuda/bindings/_internal/_nvml.pyx":1555
 *         global __nvmlDeviceGetAccountingBufferSize
 *         __nvmlDeviceGetAccountingBufferSize = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAccountingBufferSize')
 *         if __nvmlDeviceGetAccountingBufferSize == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1561
 * 
 *         global __nvmlDeviceGetRetiredPages
 *         __nvmlDeviceGetRetiredPages = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRetiredPages')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetRetiredPages == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRetiredPages = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetRetiredPages);

                /* "cuda/bindings/_internal/_nvml.pyx":1562
 *         global __nvmlDeviceGetRetiredPages
 *         __nvmlDeviceGetRetiredPages = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRetiredPages')
 *         if __nvmlDeviceGetRetiredPages == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRetiredPages == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1563
 *         __nvmlDeviceGetRetiredPages = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRetiredPages')
 *         if __nvmlDeviceGetRetiredPages == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetRetiredPages = dlsym(handle, 'nvmlDeviceGetRetiredPages')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1564
 *         if __nvmlDeviceGetRetiredPages == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetRetiredPages = dlsym(handle, 'nvmlDeviceGetRetiredPages')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1564, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1563
 *         __nvmlDeviceGetRetiredPages = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRetiredPages')
 *         if __nvmlDeviceGetRetiredPages == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetRetiredPages = dlsym(handle, 'nvmlDeviceGetRetiredPages')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1565
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetRetiredPages = dlsym(handle, 'nvmlDeviceGetRetiredPages')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetRetiredPages_v2
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRetiredPages = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetRetiredPages);

                  /* "cuda/bindings/_internal/_nvml.pyx":1562
 *         global __nvmlDeviceGetRetiredPages
 *         __nvmlDeviceGetRetiredPages = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRetiredPages')
 *         if __nvmlDeviceGetRetiredPages == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1568
 * 
 *         global __nvmlDeviceGetRetiredPages_v2
 *         __nvmlDeviceGetRetiredPages_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRetiredPages_v2')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetRetiredPages_v2 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRetiredPages_v2 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetRetiredPages_v2);

                /* "cuda/bindings/_internal/_nvml.pyx":1569
 *         global __nvmlDeviceGetRetiredPages_v2
 *         __nvmlDeviceGetRetiredPages_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRetiredPages_v2')
 *         if __nvmlDeviceGetRetiredPages_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRetiredPages_v2 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1570
 *         __nvmlDeviceGetRetiredPages_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRetiredPages_v2')
 *         if __nvmlDeviceGetRetiredPages_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetRetiredPages_v2 = dlsym(handle, 'nvmlDeviceGetRetiredPages_v2')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1571
 *         if __nvmlDeviceGetRetiredPages_v2 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetRetiredPages_v2 = dlsym(handle, 'nvmlDeviceGetRetiredPages_v2')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1571, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1570
 *         __nvmlDeviceGetRetiredPages_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRetiredPages_v2')
 *         if __nvmlDeviceGetRetiredPages_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetRetiredPages_v2 = dlsym(handle, 'nvmlDeviceGetRetiredPages_v2')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1572
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetRetiredPages_v2 = dlsym(handle, 'nvmlDeviceGetRetiredPages_v2')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetRetiredPagesPendingStatus
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRetiredPages_v2 = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetRetiredPages_v2);

                  /* "cuda/bindings/_internal/_nvml.pyx":1569
 *         global __nvmlDeviceGetRetiredPages_v2
 *         __nvmlDeviceGetRetiredPages_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRetiredPages_v2')
 *         if __nvmlDeviceGetRetiredPages_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1575
 * 
 *         global __nvmlDeviceGetRetiredPagesPendingStatus
 *         __nvmlDeviceGetRetiredPagesPendingStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRetiredPagesPendingStatus')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetRetiredPagesPendingStatus == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRetiredPagesPendingStatus = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetRetiredPagesPending);

                /* "cuda/bindings/_internal/_nvml.pyx":1576
 *         global __nvmlDeviceGetRetiredPagesPendingStatus
 *         __nvmlDeviceGetRetiredPagesPendingStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRetiredPagesPendingStatus')
 *         if __nvmlDeviceGetRetiredPagesPendingStatus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRetiredPagesPendingStatus == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1577
 *         __nvmlDeviceGetRetiredPagesPendingStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRetiredPagesPendingStatus')
 *         if __nvmlDeviceGetRetiredPagesPendingStatus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetRetiredPagesPendingStatus = dlsym(handle, 'nvmlDeviceGetRetiredPagesPendingStatus')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1578
 *         if __nvmlDeviceGetRetiredPagesPendingStatus == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetRetiredPagesPendingStatus = dlsym(handle, 'nvmlDeviceGetRetiredPagesPendingStatus')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1578, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1577
 *         __nvmlDeviceGetRetiredPagesPendingStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRetiredPagesPendingStatus')
 *         if __nvmlDeviceGetRetiredPagesPendingStatus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetRetiredPagesPendingStatus = dlsym(handle, 'nvmlDeviceGetRetiredPagesPendingStatus')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1579
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetRetiredPagesPendingStatus = dlsym(handle, 'nvmlDeviceGetRetiredPagesPendingStatus')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetRemappedRows
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRetiredPagesPendingStatus = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetRetiredPagesPending);

                  /* "cuda/bindings/_internal/_nvml.pyx":1576
 *         global __nvmlDeviceGetRetiredPagesPendingStatus
 *         __nvmlDeviceGetRetiredPagesPendingStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRetiredPagesPendingStatus')
 *         if __nvmlDeviceGetRetiredPagesPendingStatus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1582
 * 
 *         global __nvmlDeviceGetRemappedRows
 *         __nvmlDeviceGetRemappedRows = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRemappedRows')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetRemappedRows == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRemappedRows = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetRemappedRows);

                /* "cuda/bindings/_internal/_nvml.pyx":1583
 *         global __nvmlDeviceGetRemappedRows
 *         __nvmlDeviceGetRemappedRows = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRemappedRows')
 *         if __nvmlDeviceGetRemappedRows == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRemappedRows == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1584
 *         __nvmlDeviceGetRemappedRows = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRemappedRows')
 *         if __nvmlDeviceGetRemappedRows == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetRemappedRows = dlsym(handle, 'nvmlDeviceGetRemappedRows')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1585
 *         if __nvmlDeviceGetRemappedRows == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetRemappedRows = dlsym(handle, 'nvmlDeviceGetRemappedRows')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1585, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1584
 *         __nvmlDeviceGetRemappedRows = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRemappedRows')
 *         if __nvmlDeviceGetRemappedRows == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetRemappedRows = dlsym(handle, 'nvmlDeviceGetRemappedRows')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1586
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetRemappedRows = dlsym(handle, 'nvmlDeviceGetRemappedRows')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetRowRemapperHistogram
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRemappedRows = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetRemappedRows);

                  /* "cuda/bindings/_internal/_nvml.pyx":1583
 *         global __nvmlDeviceGetRemappedRows
 *         __nvmlDeviceGetRemappedRows = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRemappedRows')
 *         if __nvmlDeviceGetRemappedRows == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1589
 * 
 *         global __nvmlDeviceGetRowRemapperHistogram
 *         __nvmlDeviceGetRowRemapperHistogram = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRowRemapperHistogram')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetRowRemapperHistogram == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRowRemapperHistogram = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetRowRemapperHistogra);

                /* "cuda/bindings/_internal/_nvml.pyx":1590
 *         global __nvmlDeviceGetRowRemapperHistogram
 *         __nvmlDeviceGetRowRemapperHistogram = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRowRemapperHistogram')
 *         if __nvmlDeviceGetRowRemapperHistogram == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRowRemapperHistogram == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1591
 *         __nvmlDeviceGetRowRemapperHistogram = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRowRemapperHistogram')
 *         if __nvmlDeviceGetRowRemapperHistogram == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetRowRemapperHistogram = dlsym(handle, 'nvmlDeviceGetRowRemapperHistogram')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1592
 *         if __nvmlDeviceGetRowRemapperHistogram == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetRowRemapperHistogram = dlsym(handle, 'nvmlDeviceGetRowRemapperHistogram')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1592, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1591
 *         __nvmlDeviceGetRowRemapperHistogram = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRowRemapperHistogram')
 *         if __nvmlDeviceGetRowRemapperHistogram == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetRowRemapperHistogram = dlsym(handle, 'nvmlDeviceGetRowRemapperHistogram')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1593
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetRowRemapperHistogram = dlsym(handle, 'nvmlDeviceGetRowRemapperHistogram')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetArchitecture
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRowRemapperHistogram = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetRowRemapperHistogra);

                  /* "cuda/bindings/_internal/_nvml.pyx":1590
 *         global __nvmlDeviceGetRowRemapperHistogram
 *         __nvmlDeviceGetRowRemapperHistogram = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRowRemapperHistogram')
 *         if __nvmlDeviceGetRowRemapperHistogram == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1596
 * 
 *         global __nvmlDeviceGetArchitecture
 *         __nvmlDeviceGetArchitecture = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetArchitecture')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetArchitecture == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetArchitecture = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetArchitecture);

                /* "cuda/bindings/_internal/_nvml.pyx":1597
 *         global __nvmlDeviceGetArchitecture
 *         __nvmlDeviceGetArchitecture = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetArchitecture')
 *         if __nvmlDeviceGetArchitecture == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetArchitecture == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1598
 *         __nvmlDeviceGetArchitecture = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetArchitecture')
 *         if __nvmlDeviceGetArchitecture == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetArchitecture = dlsym(handle, 'nvmlDeviceGetArchitecture')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1599
 *         if __nvmlDeviceGetArchitecture == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetArchitecture = dlsym(handle, 'nvmlDeviceGetArchitecture')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1599, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1598
 *         __nvmlDeviceGetArchitecture = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetArchitecture')
 *         if __nvmlDeviceGetArchitecture == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetArchitecture = dlsym(handle, 'nvmlDeviceGetArchitecture')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1600
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetArchitecture = dlsym(handle, 'nvmlDeviceGetArchitecture')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetClkMonStatus
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetArchitecture = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetArchitecture);

                  /* "cuda/bindings/_internal/_nvml.pyx":1597
 *         global __nvmlDeviceGetArchitecture
 *         __nvmlDeviceGetArchitecture = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetArchitecture')
 *         if __nvmlDeviceGetArchitecture == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1603
 * 
 *         global __nvmlDeviceGetClkMonStatus
 *         __nvmlDeviceGetClkMonStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetClkMonStatus')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetClkMonStatus == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClkMonStatus = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetClkMonStatus);

                /* "cuda/bindings/_internal/_nvml.pyx":1604
 *         global __nvmlDeviceGetClkMonStatus
 *         __nvmlDeviceGetClkMonStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetClkMonStatus')
 *         if __nvmlDeviceGetClkMonStatus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClkMonStatus == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1605
 *         __nvmlDeviceGetClkMonStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetClkMonStatus')
 *         if __nvmlDeviceGetClkMonStatus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetClkMonStatus = dlsym(handle, 'nvmlDeviceGetClkMonStatus')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1606
 *         if __nvmlDeviceGetClkMonStatus == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetClkMonStatus = dlsym(handle, 'nvmlDeviceGetClkMonStatus')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1606, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1605
 *         __nvmlDeviceGetClkMonStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetClkMonStatus')
 *         if __nvmlDeviceGetClkMonStatus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetClkMonStatus = dlsym(handle, 'nvmlDeviceGetClkMonStatus')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1607
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetClkMonStatus = dlsym(handle, 'nvmlDeviceGetClkMonStatus')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetProcessUtilization
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClkMonStatus = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetClkMonStatus);

                  /* "cuda/bindings/_internal/_nvml.pyx":1604
 *         global __nvmlDeviceGetClkMonStatus
 *         __nvmlDeviceGetClkMonStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetClkMonStatus')
 *         if __nvmlDeviceGetClkMonStatus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1610
 * 
 *         global __nvmlDeviceGetProcessUtilization
 *         __nvmlDeviceGetProcessUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetProcessUtilization')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetProcessUtilization == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetProcessUtilization = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetProcessUtilization);

                /* "cuda/bindings/_internal/_nvml.pyx":1611
 *         global __nvmlDeviceGetProcessUtilization
 *         __nvmlDeviceGetProcessUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetProcessUtilization')
 *         if __nvmlDeviceGetProcessUtilization == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetProcessUtilization == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1612
 *         __nvmlDeviceGetProcessUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetProcessUtilization')
 *         if __nvmlDeviceGetProcessUtilization == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetProcessUtilization = dlsym(handle, 'nvmlDeviceGetProcessUtilization')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1613
 *         if __nvmlDeviceGetProcessUtilization == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetProcessUtilization = dlsym(handle, 'nvmlDeviceGetProcessUtilization')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1613, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1612
 *         __nvmlDeviceGetProcessUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetProcessUtilization')
 *         if __nvmlDeviceGetProcessUtilization == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetProcessUtilization = dlsym(handle, 'nvmlDeviceGetProcessUtilization')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1614
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetProcessUtilization = dlsym(handle, 'nvmlDeviceGetProcessUtilization')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetProcessesUtilizationInfo
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetProcessUtilization = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetProcessUtilization);

                  /* "cuda/bindings/_internal/_nvml.pyx":1611
 *         global __nvmlDeviceGetProcessUtilization
 *         __nvmlDeviceGetProcessUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetProcessUtilization')
 *         if __nvmlDeviceGetProcessUtilization == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1617
 * 
 *         global __nvmlDeviceGetProcessesUtilizationInfo
 *         __nvmlDeviceGetProcessesUtilizationInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetProcessesUtilizationInfo')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetProcessesUtilizationInfo == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetProcessesUtilizationInfo = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetProcessesUtilizatio);

                /* "cuda/bindings/_internal/_nvml.pyx":1618
 *         global __nvmlDeviceGetProcessesUtilizationInfo
 *         __nvmlDeviceGetProcessesUtilizationInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetProcessesUtilizationInfo')
 *         if __nvmlDeviceGetProcessesUtilizationInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetProcessesUtilizationInfo == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1619
 *         __nvmlDeviceGetProcessesUtilizationInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetProcessesUtilizationInfo')
 *         if __nvmlDeviceGetProcessesUtilizationInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetProcessesUtilizationInfo = dlsym(handle, 'nvmlDeviceGetProcessesUtilizationInfo')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1620
 *         if __nvmlDeviceGetProcessesUtilizationInfo == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetProcessesUtilizationInfo = dlsym(handle, 'nvmlDeviceGetProcessesUtilizationInfo')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1620, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1619
 *         __nvmlDeviceGetProcessesUtilizationInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetProcessesUtilizationInfo')
 *         if __nvmlDeviceGetProcessesUtilizationInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetProcessesUtilizationInfo = dlsym(handle, 'nvmlDeviceGetProcessesUtilizationInfo')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1621
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetProcessesUtilizationInfo = dlsym(handle, 'nvmlDeviceGetProcessesUtilizationInfo')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetPlatformInfo
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetProcessesUtilizationInfo = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetProcessesUtilizatio);

                  /* "cuda/bindings/_internal/_nvml.pyx":1618
 *         global __nvmlDeviceGetProcessesUtilizationInfo
 *         __nvmlDeviceGetProcessesUtilizationInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetProcessesUtilizationInfo')
 *         if __nvmlDeviceGetProcessesUtilizationInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1624
 * 
 *         global __nvmlDeviceGetPlatformInfo
 *         __nvmlDeviceGetPlatformInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPlatformInfo')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetPlatformInfo == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPlatformInfo = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetPlatformInfo);

                /* "cuda/bindings/_internal/_nvml.pyx":1625
 *         global __nvmlDeviceGetPlatformInfo
 *         __nvmlDeviceGetPlatformInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPlatformInfo')
 *         if __nvmlDeviceGetPlatformInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPlatformInfo == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1626
 *         __nvmlDeviceGetPlatformInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPlatformInfo')
 *         if __nvmlDeviceGetPlatformInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPlatformInfo = dlsym(handle, 'nvmlDeviceGetPlatformInfo')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1627
 *         if __nvmlDeviceGetPlatformInfo == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetPlatformInfo = dlsym(handle, 'nvmlDeviceGetPlatformInfo')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1627, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1626
 *         __nvmlDeviceGetPlatformInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPlatformInfo')
 *         if __nvmlDeviceGetPlatformInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPlatformInfo = dlsym(handle, 'nvmlDeviceGetPlatformInfo')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1628
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetPlatformInfo = dlsym(handle, 'nvmlDeviceGetPlatformInfo')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlUnitSetLedState
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPlatformInfo = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetPlatformInfo);

                  /* "cuda/bindings/_internal/_nvml.pyx":1625
 *         global __nvmlDeviceGetPlatformInfo
 *         __nvmlDeviceGetPlatformInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPlatformInfo')
 *         if __nvmlDeviceGetPlatformInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1631
 * 
 *         global __nvmlUnitSetLedState
 *         __nvmlUnitSetLedState = dlsym(RTLD_DEFAULT, 'nvmlUnitSetLedState')             # <<<<<<<<<<<<<<
 *         if __nvmlUnitSetLedState == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitSetLedState = dlsym(RTLD_DEFAULT, __pyx_k_nvmlUnitSetLedState);

                /* "cuda/bindings/_internal/_nvml.pyx":1632
 *         global __nvmlUnitSetLedState
 *         __nvmlUnitSetLedState = dlsym(RTLD_DEFAULT, 'nvmlUnitSetLedState')
 *         if __nvmlUnitSetLedState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitSetLedState == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1633
 *         __nvmlUnitSetLedState = dlsym(RTLD_DEFAULT, 'nvmlUnitSetLedState')
 *         if __nvmlUnitSetLedState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlUnitSetLedState = dlsym(handle, 'nvmlUnitSetLedState')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1634
 *         if __nvmlUnitSetLedState == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlUnitSetLedState = dlsym(handle, 'nvmlUnitSetLedState')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1634, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1633
 *         __nvmlUnitSetLedState = dlsym(RTLD_DEFAULT, 'nvmlUnitSetLedState')
 *         if __nvmlUnitSetLedState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlUnitSetLedState = dlsym(handle, 'nvmlUnitSetLedState')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1635
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlUnitSetLedState = dlsym(handle, 'nvmlUnitSetLedState')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetPersistenceMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitSetLedState = dlsym(__pyx_v_handle, __pyx_k_nvmlUnitSetLedState);

                  /* "cuda/bindings/_internal/_nvml.pyx":1632
 *         global __nvmlUnitSetLedState
 *         __nvmlUnitSetLedState = dlsym(RTLD_DEFAULT, 'nvmlUnitSetLedState')
 *         if __nvmlUnitSetLedState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1638
 * 
 *         global __nvmlDeviceSetPersistenceMode
 *         __nvmlDeviceSetPersistenceMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetPersistenceMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetPersistenceMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPersistenceMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetPersistenceMode);

                /* "cuda/bindings/_internal/_nvml.pyx":1639
 *         global __nvmlDeviceSetPersistenceMode
 *         __nvmlDeviceSetPersistenceMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetPersistenceMode')
 *         if __nvmlDeviceSetPersistenceMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPersistenceMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1640
 *         __nvmlDeviceSetPersistenceMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetPersistenceMode')
 *         if __nvmlDeviceSetPersistenceMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetPersistenceMode = dlsym(handle, 'nvmlDeviceSetPersistenceMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1641
 *         if __nvmlDeviceSetPersistenceMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetPersistenceMode = dlsym(handle, 'nvmlDeviceSetPersistenceMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1641, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1640
 *         __nvmlDeviceSetPersistenceMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetPersistenceMode')
 *         if __nvmlDeviceSetPersistenceMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetPersistenceMode = dlsym(handle, 'nvmlDeviceSetPersistenceMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1642
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetPersistenceMode = dlsym(handle, 'nvmlDeviceSetPersistenceMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetComputeMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPersistenceMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetPersistenceMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":1639
 *         global __nvmlDeviceSetPersistenceMode
 *         __nvmlDeviceSetPersistenceMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetPersistenceMode')
 *         if __nvmlDeviceSetPersistenceMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1645
 * 
 *         global __nvmlDeviceSetComputeMode
 *         __nvmlDeviceSetComputeMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetComputeMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetComputeMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetComputeMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetComputeMode);

                /* "cuda/bindings/_internal/_nvml.pyx":1646
 *         global __nvmlDeviceSetComputeMode
 *         __nvmlDeviceSetComputeMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetComputeMode')
 *         if __nvmlDeviceSetComputeMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetComputeMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1647
 *         __nvmlDeviceSetComputeMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetComputeMode')
 *         if __nvmlDeviceSetComputeMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetComputeMode = dlsym(handle, 'nvmlDeviceSetComputeMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1648
 *         if __nvmlDeviceSetComputeMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetComputeMode = dlsym(handle, 'nvmlDeviceSetComputeMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1648, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1647
 *         __nvmlDeviceSetComputeMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetComputeMode')
 *         if __nvmlDeviceSetComputeMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetComputeMode = dlsym(handle, 'nvmlDeviceSetComputeMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1649
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetComputeMode = dlsym(handle, 'nvmlDeviceSetComputeMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetEccMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetComputeMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetComputeMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":1646
 *         global __nvmlDeviceSetComputeMode
 *         __nvmlDeviceSetComputeMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetComputeMode')
 *         if __nvmlDeviceSetComputeMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1652
 * 
 *         global __nvmlDeviceSetEccMode
 *         __nvmlDeviceSetEccMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetEccMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetEccMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetEccMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetEccMode);

                /* "cuda/bindings/_internal/_nvml.pyx":1653
 *         global __nvmlDeviceSetEccMode
 *         __nvmlDeviceSetEccMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetEccMode')
 *         if __nvmlDeviceSetEccMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetEccMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1654
 *         __nvmlDeviceSetEccMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetEccMode')
 *         if __nvmlDeviceSetEccMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetEccMode = dlsym(handle, 'nvmlDeviceSetEccMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1655
 *         if __nvmlDeviceSetEccMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetEccMode = dlsym(handle, 'nvmlDeviceSetEccMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1655, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1654
 *         __nvmlDeviceSetEccMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetEccMode')
 *         if __nvmlDeviceSetEccMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetEccMode = dlsym(handle, 'nvmlDeviceSetEccMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1656
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetEccMode = dlsym(handle, 'nvmlDeviceSetEccMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceClearEccErrorCounts
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetEccMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetEccMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":1653
 *         global __nvmlDeviceSetEccMode
 *         __nvmlDeviceSetEccMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetEccMode')
 *         if __nvmlDeviceSetEccMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1659
 * 
 *         global __nvmlDeviceClearEccErrorCounts
 *         __nvmlDeviceClearEccErrorCounts = dlsym(RTLD_DEFAULT, 'nvmlDeviceClearEccErrorCounts')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceClearEccErrorCounts == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearEccErrorCounts = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceClearEccErrorCounts);

                /* "cuda/bindings/_internal/_nvml.pyx":1660
 *         global __nvmlDeviceClearEccErrorCounts
 *         __nvmlDeviceClearEccErrorCounts = dlsym(RTLD_DEFAULT, 'nvmlDeviceClearEccErrorCounts')
 *         if __nvmlDeviceClearEccErrorCounts == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearEccErrorCounts == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1661
 *         __nvmlDeviceClearEccErrorCounts = dlsym(RTLD_DEFAULT, 'nvmlDeviceClearEccErrorCounts')
 *         if __nvmlDeviceClearEccErrorCounts == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceClearEccErrorCounts = dlsym(handle, 'nvmlDeviceClearEccErrorCounts')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1662
 *         if __nvmlDeviceClearEccErrorCounts == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceClearEccErrorCounts = dlsym(handle, 'nvmlDeviceClearEccErrorCounts')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1662, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1661
 *         __nvmlDeviceClearEccErrorCounts = dlsym(RTLD_DEFAULT, 'nvmlDeviceClearEccErrorCounts')
 *         if __nvmlDeviceClearEccErrorCounts == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceClearEccErrorCounts = dlsym(handle, 'nvmlDeviceClearEccErrorCounts')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1663
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceClearEccErrorCounts = dlsym(handle, 'nvmlDeviceClearEccErrorCounts')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetDriverModel
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearEccErrorCounts = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceClearEccErrorCounts);

                  /* "cuda/bindings/_internal/_nvml.pyx":1660
 *         global __nvmlDeviceClearEccErrorCounts
 *         __nvmlDeviceClearEccErrorCounts = dlsym(RTLD_DEFAULT, 'nvmlDeviceClearEccErrorCounts')
 *         if __nvmlDeviceClearEccErrorCounts == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1666
 * 
 *         global __nvmlDeviceSetDriverModel
 *         __nvmlDeviceSetDriverModel = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetDriverModel')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetDriverModel == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDriverModel = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetDriverModel);

                /* "cuda/bindings/_internal/_nvml.pyx":1667
 *         global __nvmlDeviceSetDriverModel
 *         __nvmlDeviceSetDriverModel = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetDriverModel')
 *         if __nvmlDeviceSetDriverModel == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDriverModel == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1668
 *         __nvmlDeviceSetDriverModel = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetDriverModel')
 *         if __nvmlDeviceSetDriverModel == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetDriverModel = dlsym(handle, 'nvmlDeviceSetDriverModel')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1669
 *         if __nvmlDeviceSetDriverModel == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetDriverModel = dlsym(handle, 'nvmlDeviceSetDriverModel')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1669, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1668
 *         __nvmlDeviceSetDriverModel = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetDriverModel')
 *         if __nvmlDeviceSetDriverModel == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetDriverModel = dlsym(handle, 'nvmlDeviceSetDriverModel')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1670
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetDriverModel = dlsym(handle, 'nvmlDeviceSetDriverModel')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetGpuLockedClocks
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDriverModel = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetDriverModel);

                  /* "cuda/bindings/_internal/_nvml.pyx":1667
 *         global __nvmlDeviceSetDriverModel
 *         __nvmlDeviceSetDriverModel = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetDriverModel')
 *         if __nvmlDeviceSetDriverModel == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1673
 * 
 *         global __nvmlDeviceSetGpuLockedClocks
 *         __nvmlDeviceSetGpuLockedClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetGpuLockedClocks')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetGpuLockedClocks == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetGpuLockedClocks = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetGpuLockedClocks);

                /* "cuda/bindings/_internal/_nvml.pyx":1674
 *         global __nvmlDeviceSetGpuLockedClocks
 *         __nvmlDeviceSetGpuLockedClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetGpuLockedClocks')
 *         if __nvmlDeviceSetGpuLockedClocks == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetGpuLockedClocks == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1675
 *         __nvmlDeviceSetGpuLockedClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetGpuLockedClocks')
 *         if __nvmlDeviceSetGpuLockedClocks == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetGpuLockedClocks = dlsym(handle, 'nvmlDeviceSetGpuLockedClocks')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1676
 *         if __nvmlDeviceSetGpuLockedClocks == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetGpuLockedClocks = dlsym(handle, 'nvmlDeviceSetGpuLockedClocks')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1676, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1675
 *         __nvmlDeviceSetGpuLockedClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetGpuLockedClocks')
 *         if __nvmlDeviceSetGpuLockedClocks == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetGpuLockedClocks = dlsym(handle, 'nvmlDeviceSetGpuLockedClocks')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1677
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetGpuLockedClocks = dlsym(handle, 'nvmlDeviceSetGpuLockedClocks')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceResetGpuLockedClocks
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetGpuLockedClocks = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetGpuLockedClocks);

                  /* "cuda/bindings/_internal/_nvml.pyx":1674
 *         global __nvmlDeviceSetGpuLockedClocks
 *         __nvmlDeviceSetGpuLockedClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetGpuLockedClocks')
 *         if __nvmlDeviceSetGpuLockedClocks == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1680
 * 
 *         global __nvmlDeviceResetGpuLockedClocks
 *         __nvmlDeviceResetGpuLockedClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceResetGpuLockedClocks')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceResetGpuLockedClocks == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceResetGpuLockedClocks = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceResetGpuLockedClocks);

                /* "cuda/bindings/_internal/_nvml.pyx":1681
 *         global __nvmlDeviceResetGpuLockedClocks
 *         __nvmlDeviceResetGpuLockedClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceResetGpuLockedClocks')
 *         if __nvmlDeviceResetGpuLockedClocks == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceResetGpuLockedClocks == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1682
 *         __nvmlDeviceResetGpuLockedClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceResetGpuLockedClocks')
 *         if __nvmlDeviceResetGpuLockedClocks == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceResetGpuLockedClocks = dlsym(handle, 'nvmlDeviceResetGpuLockedClocks')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1683
 *         if __nvmlDeviceResetGpuLockedClocks == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceResetGpuLockedClocks = dlsym(handle, 'nvmlDeviceResetGpuLockedClocks')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1683, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1682
 *         __nvmlDeviceResetGpuLockedClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceResetGpuLockedClocks')
 *         if __nvmlDeviceResetGpuLockedClocks == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceResetGpuLockedClocks = dlsym(handle, 'nvmlDeviceResetGpuLockedClocks')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1684
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceResetGpuLockedClocks = dlsym(handle, 'nvmlDeviceResetGpuLockedClocks')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetMemoryLockedClocks
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceResetGpuLockedClocks = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceResetGpuLockedClocks);

                  /* "cuda/bindings/_internal/_nvml.pyx":1681
 *         global __nvmlDeviceResetGpuLockedClocks
 *         __nvmlDeviceResetGpuLockedClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceResetGpuLockedClocks')
 *         if __nvmlDeviceResetGpuLockedClocks == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1687
 * 
 *         global __nvmlDeviceSetMemoryLockedClocks
 *         __nvmlDeviceSetMemoryLockedClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetMemoryLockedClocks')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetMemoryLockedClocks == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetMemoryLockedClocks = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetMemoryLockedClocks);

                /* "cuda/bindings/_internal/_nvml.pyx":1688
 *         global __nvmlDeviceSetMemoryLockedClocks
 *         __nvmlDeviceSetMemoryLockedClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetMemoryLockedClocks')
 *         if __nvmlDeviceSetMemoryLockedClocks == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetMemoryLockedClocks == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1689
 *         __nvmlDeviceSetMemoryLockedClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetMemoryLockedClocks')
 *         if __nvmlDeviceSetMemoryLockedClocks == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetMemoryLockedClocks = dlsym(handle, 'nvmlDeviceSetMemoryLockedClocks')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1690
 *         if __nvmlDeviceSetMemoryLockedClocks == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetMemoryLockedClocks = dlsym(handle, 'nvmlDeviceSetMemoryLockedClocks')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1690, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1689
 *         __nvmlDeviceSetMemoryLockedClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetMemoryLockedClocks')
 *         if __nvmlDeviceSetMemoryLockedClocks == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetMemoryLockedClocks = dlsym(handle, 'nvmlDeviceSetMemoryLockedClocks')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1691
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetMemoryLockedClocks = dlsym(handle, 'nvmlDeviceSetMemoryLockedClocks')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceResetMemoryLockedClocks
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetMemoryLockedClocks = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetMemoryLockedClocks);

                  /* "cuda/bindings/_internal/_nvml.pyx":1688
 *         global __nvmlDeviceSetMemoryLockedClocks
 *         __nvmlDeviceSetMemoryLockedClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetMemoryLockedClocks')
 *         if __nvmlDeviceSetMemoryLockedClocks == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1694
 * 
 *         global __nvmlDeviceResetMemoryLockedClocks
 *         __nvmlDeviceResetMemoryLockedClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceResetMemoryLockedClocks')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceResetMemoryLockedClocks == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceResetMemoryLockedClocks = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceResetMemoryLockedClock);

                /* "cuda/bindings/_internal/_nvml.pyx":1695
 *         global __nvmlDeviceResetMemoryLockedClocks
 *         __nvmlDeviceResetMemoryLockedClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceResetMemoryLockedClocks')
 *         if __nvmlDeviceResetMemoryLockedClocks == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceResetMemoryLockedClocks == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1696
 *         __nvmlDeviceResetMemoryLockedClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceResetMemoryLockedClocks')
 *         if __nvmlDeviceResetMemoryLockedClocks == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceResetMemoryLockedClocks = dlsym(handle, 'nvmlDeviceResetMemoryLockedClocks')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1697
 *         if __nvmlDeviceResetMemoryLockedClocks == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceResetMemoryLockedClocks = dlsym(handle, 'nvmlDeviceResetMemoryLockedClocks')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1697, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1696
 *         __nvmlDeviceResetMemoryLockedClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceResetMemoryLockedClocks')
 *         if __nvmlDeviceResetMemoryLockedClocks == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceResetMemoryLockedClocks = dlsym(handle, 'nvmlDeviceResetMemoryLockedClocks')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1698
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceResetMemoryLockedClocks = dlsym(handle, 'nvmlDeviceResetMemoryLockedClocks')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetAutoBoostedClocksEnabled
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceResetMemoryLockedClocks = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceResetMemoryLockedClock);

                  /* "cuda/bindings/_internal/_nvml.pyx":1695
 *         global __nvmlDeviceResetMemoryLockedClocks
 *         __nvmlDeviceResetMemoryLockedClocks = dlsym(RTLD_DEFAULT, 'nvmlDeviceResetMemoryLockedClocks')
 *         if __nvmlDeviceResetMemoryLockedClocks == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1701
 * 
 *         global __nvmlDeviceSetAutoBoostedClocksEnabled
 *         __nvmlDeviceSetAutoBoostedClocksEnabled = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetAutoBoostedClocksEnabled')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetAutoBoostedClocksEnabled == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetAutoBoostedClocksEnabled = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetAutoBoostedClocksEn);

                /* "cuda/bindings/_internal/_nvml.pyx":1702
 *         global __nvmlDeviceSetAutoBoostedClocksEnabled
 *         __nvmlDeviceSetAutoBoostedClocksEnabled = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetAutoBoostedClocksEnabled')
 *         if __nvmlDeviceSetAutoBoostedClocksEnabled == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetAutoBoostedClocksEnabled == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1703
 *         __nvmlDeviceSetAutoBoostedClocksEnabled = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetAutoBoostedClocksEnabled')
 *         if __nvmlDeviceSetAutoBoostedClocksEnabled == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetAutoBoostedClocksEnabled = dlsym(handle, 'nvmlDeviceSetAutoBoostedClocksEnabled')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1704
 *         if __nvmlDeviceSetAutoBoostedClocksEnabled == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetAutoBoostedClocksEnabled = dlsym(handle, 'nvmlDeviceSetAutoBoostedClocksEnabled')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1704, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1703
 *         __nvmlDeviceSetAutoBoostedClocksEnabled = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetAutoBoostedClocksEnabled')
 *         if __nvmlDeviceSetAutoBoostedClocksEnabled == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetAutoBoostedClocksEnabled = dlsym(handle, 'nvmlDeviceSetAutoBoostedClocksEnabled')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1705
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetAutoBoostedClocksEnabled = dlsym(handle, 'nvmlDeviceSetAutoBoostedClocksEnabled')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetDefaultAutoBoostedClocksEnabled
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetAutoBoostedClocksEnabled = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetAutoBoostedClocksEn);

                  /* "cuda/bindings/_internal/_nvml.pyx":1702
 *         global __nvmlDeviceSetAutoBoostedClocksEnabled
 *         __nvmlDeviceSetAutoBoostedClocksEnabled = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetAutoBoostedClocksEnabled')
 *         if __nvmlDeviceSetAutoBoostedClocksEnabled == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1708
 * 
 *         global __nvmlDeviceSetDefaultAutoBoostedClocksEnabled
 *         __nvmlDeviceSetDefaultAutoBoostedClocksEnabled = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetDefaultAutoBoostedClocksEnabled')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetDefaultAutoBoostedClocksEnabled == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDefaultAutoBoostedClocksEnabled = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetDefaultAutoBoostedC);

                /* "cuda/bindings/_internal/_nvml.pyx":1709
 *         global __nvmlDeviceSetDefaultAutoBoostedClocksEnabled
 *         __nvmlDeviceSetDefaultAutoBoostedClocksEnabled = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetDefaultAutoBoostedClocksEnabled')
 *         if __nvmlDeviceSetDefaultAutoBoostedClocksEnabled == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDefaultAutoBoostedClocksEnabled == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1710
 *         __nvmlDeviceSetDefaultAutoBoostedClocksEnabled = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetDefaultAutoBoostedClocksEnabled')
 *         if __nvmlDeviceSetDefaultAutoBoostedClocksEnabled == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetDefaultAutoBoostedClocksEnabled = dlsym(handle, 'nvmlDeviceSetDefaultAutoBoostedClocksEnabled')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1711
 *         if __nvmlDeviceSetDefaultAutoBoostedClocksEnabled == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetDefaultAutoBoostedClocksEnabled = dlsym(handle, 'nvmlDeviceSetDefaultAutoBoostedClocksEnabled')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1711, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1710
 *         __nvmlDeviceSetDefaultAutoBoostedClocksEnabled = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetDefaultAutoBoostedClocksEnabled')
 *         if __nvmlDeviceSetDefaultAutoBoostedClocksEnabled == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetDefaultAutoBoostedClocksEnabled = dlsym(handle, 'nvmlDeviceSetDefaultAutoBoostedClocksEnabled')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1712
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetDefaultAutoBoostedClocksEnabled = dlsym(handle, 'nvmlDeviceSetDefaultAutoBoostedClocksEnabled')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetDefaultFanSpeed_v2
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDefaultAutoBoostedClocksEnabled = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetDefaultAutoBoostedC);

                  /* "cuda/bindings/_internal/_nvml.pyx":1709
 *         global __nvmlDeviceSetDefaultAutoBoostedClocksEnabled
 *         __nvmlDeviceSetDefaultAutoBoostedClocksEnabled = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetDefaultAutoBoostedClocksEnabled')
 *         if __nvmlDeviceSetDefaultAutoBoostedClocksEnabled == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1715
 * 
 *         global __nvmlDeviceSetDefaultFanSpeed_v2
 *         __nvmlDeviceSetDefaultFanSpeed_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetDefaultFanSpeed_v2')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetDefaultFanSpeed_v2 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDefaultFanSpeed_v2 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetDefaultFanSpeed_v2);

                /* "cuda/bindings/_internal/_nvml.pyx":1716
 *         global __nvmlDeviceSetDefaultFanSpeed_v2
 *         __nvmlDeviceSetDefaultFanSpeed_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetDefaultFanSpeed_v2')
 *         if __nvmlDeviceSetDefaultFanSpeed_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDefaultFanSpeed_v2 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1717
 *         __nvmlDeviceSetDefaultFanSpeed_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetDefaultFanSpeed_v2')
 *         if __nvmlDeviceSetDefaultFanSpeed_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetDefaultFanSpeed_v2 = dlsym(handle, 'nvmlDeviceSetDefaultFanSpeed_v2')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1718
 *         if __nvmlDeviceSetDefaultFanSpeed_v2 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetDefaultFanSpeed_v2 = dlsym(handle, 'nvmlDeviceSetDefaultFanSpeed_v2')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1718, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1717
 *         __nvmlDeviceSetDefaultFanSpeed_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetDefaultFanSpeed_v2')
 *         if __nvmlDeviceSetDefaultFanSpeed_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetDefaultFanSpeed_v2 = dlsym(handle, 'nvmlDeviceSetDefaultFanSpeed_v2')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1719
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetDefaultFanSpeed_v2 = dlsym(handle, 'nvmlDeviceSetDefaultFanSpeed_v2')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetFanControlPolicy
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDefaultFanSpeed_v2 = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetDefaultFanSpeed_v2);

                  /* "cuda/bindings/_internal/_nvml.pyx":1716
 *         global __nvmlDeviceSetDefaultFanSpeed_v2
 *         __nvmlDeviceSetDefaultFanSpeed_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetDefaultFanSpeed_v2')
 *         if __nvmlDeviceSetDefaultFanSpeed_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1722
 * 
 *         global __nvmlDeviceSetFanControlPolicy
 *         __nvmlDeviceSetFanControlPolicy = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetFanControlPolicy')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetFanControlPolicy == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetFanControlPolicy = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetFanControlPolicy);

                /* "cuda/bindings/_internal/_nvml.pyx":1723
 *         global __nvmlDeviceSetFanControlPolicy
 *         __nvmlDeviceSetFanControlPolicy = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetFanControlPolicy')
 *         if __nvmlDeviceSetFanControlPolicy == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetFanControlPolicy == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1724
 *         __nvmlDeviceSetFanControlPolicy = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetFanControlPolicy')
 *         if __nvmlDeviceSetFanControlPolicy == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetFanControlPolicy = dlsym(handle, 'nvmlDeviceSetFanControlPolicy')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1725
 *         if __nvmlDeviceSetFanControlPolicy == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetFanControlPolicy = dlsym(handle, 'nvmlDeviceSetFanControlPolicy')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1725, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1724
 *         __nvmlDeviceSetFanControlPolicy = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetFanControlPolicy')
 *         if __nvmlDeviceSetFanControlPolicy == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetFanControlPolicy = dlsym(handle, 'nvmlDeviceSetFanControlPolicy')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1726
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetFanControlPolicy = dlsym(handle, 'nvmlDeviceSetFanControlPolicy')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetTemperatureThreshold
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetFanControlPolicy = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetFanControlPolicy);

                  /* "cuda/bindings/_internal/_nvml.pyx":1723
 *         global __nvmlDeviceSetFanControlPolicy
 *         __nvmlDeviceSetFanControlPolicy = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetFanControlPolicy')
 *         if __nvmlDeviceSetFanControlPolicy == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1729
 * 
 *         global __nvmlDeviceSetTemperatureThreshold
 *         __nvmlDeviceSetTemperatureThreshold = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetTemperatureThreshold')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetTemperatureThreshold == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetTemperatureThreshold = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetTemperatureThreshol);

                /* "cuda/bindings/_internal/_nvml.pyx":1730
 *         global __nvmlDeviceSetTemperatureThreshold
 *         __nvmlDeviceSetTemperatureThreshold = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetTemperatureThreshold')
 *         if __nvmlDeviceSetTemperatureThreshold == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetTemperatureThreshold == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1731
 *         __nvmlDeviceSetTemperatureThreshold = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetTemperatureThreshold')
 *         if __nvmlDeviceSetTemperatureThreshold == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetTemperatureThreshold = dlsym(handle, 'nvmlDeviceSetTemperatureThreshold')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1732
 *         if __nvmlDeviceSetTemperatureThreshold == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetTemperatureThreshold = dlsym(handle, 'nvmlDeviceSetTemperatureThreshold')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1732, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1731
 *         __nvmlDeviceSetTemperatureThreshold = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetTemperatureThreshold')
 *         if __nvmlDeviceSetTemperatureThreshold == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetTemperatureThreshold = dlsym(handle, 'nvmlDeviceSetTemperatureThreshold')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1733
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetTemperatureThreshold = dlsym(handle, 'nvmlDeviceSetTemperatureThreshold')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetPowerManagementLimit
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetTemperatureThreshold = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetTemperatureThreshol);

                  /* "cuda/bindings/_internal/_nvml.pyx":1730
 *         global __nvmlDeviceSetTemperatureThreshold
 *         __nvmlDeviceSetTemperatureThreshold = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetTemperatureThreshold')
 *         if __nvmlDeviceSetTemperatureThreshold == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1736
 * 
 *         global __nvmlDeviceSetPowerManagementLimit
 *         __nvmlDeviceSetPowerManagementLimit = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetPowerManagementLimit')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetPowerManagementLimit == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPowerManagementLimit = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetPowerManagementLimi);

                /* "cuda/bindings/_internal/_nvml.pyx":1737
 *         global __nvmlDeviceSetPowerManagementLimit
 *         __nvmlDeviceSetPowerManagementLimit = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetPowerManagementLimit')
 *         if __nvmlDeviceSetPowerManagementLimit == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPowerManagementLimit == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1738
 *         __nvmlDeviceSetPowerManagementLimit = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetPowerManagementLimit')
 *         if __nvmlDeviceSetPowerManagementLimit == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetPowerManagementLimit = dlsym(handle, 'nvmlDeviceSetPowerManagementLimit')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1739
 *         if __nvmlDeviceSetPowerManagementLimit == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetPowerManagementLimit = dlsym(handle, 'nvmlDeviceSetPowerManagementLimit')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1739, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1738
 *         __nvmlDeviceSetPowerManagementLimit = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetPowerManagementLimit')
 *         if __nvmlDeviceSetPowerManagementLimit == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetPowerManagementLimit = dlsym(handle, 'nvmlDeviceSetPowerManagementLimit')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1740
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetPowerManagementLimit = dlsym(handle, 'nvmlDeviceSetPowerManagementLimit')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetGpuOperationMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPowerManagementLimit = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetPowerManagementLimi);

                  /* "cuda/bindings/_internal/_nvml.pyx":1737
 *         global __nvmlDeviceSetPowerManagementLimit
 *         __nvmlDeviceSetPowerManagementLimit = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetPowerManagementLimit')
 *         if __nvmlDeviceSetPowerManagementLimit == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1743
 * 
 *         global __nvmlDeviceSetGpuOperationMode
 *         __nvmlDeviceSetGpuOperationMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetGpuOperationMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetGpuOperationMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetGpuOperationMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetGpuOperationMode);

                /* "cuda/bindings/_internal/_nvml.pyx":1744
 *         global __nvmlDeviceSetGpuOperationMode
 *         __nvmlDeviceSetGpuOperationMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetGpuOperationMode')
 *         if __nvmlDeviceSetGpuOperationMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetGpuOperationMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1745
 *         __nvmlDeviceSetGpuOperationMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetGpuOperationMode')
 *         if __nvmlDeviceSetGpuOperationMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetGpuOperationMode = dlsym(handle, 'nvmlDeviceSetGpuOperationMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1746
 *         if __nvmlDeviceSetGpuOperationMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetGpuOperationMode = dlsym(handle, 'nvmlDeviceSetGpuOperationMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1746, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1745
 *         __nvmlDeviceSetGpuOperationMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetGpuOperationMode')
 *         if __nvmlDeviceSetGpuOperationMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetGpuOperationMode = dlsym(handle, 'nvmlDeviceSetGpuOperationMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1747
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetGpuOperationMode = dlsym(handle, 'nvmlDeviceSetGpuOperationMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetAPIRestriction
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetGpuOperationMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetGpuOperationMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":1744
 *         global __nvmlDeviceSetGpuOperationMode
 *         __nvmlDeviceSetGpuOperationMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetGpuOperationMode')
 *         if __nvmlDeviceSetGpuOperationMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1750
 * 
 *         global __nvmlDeviceSetAPIRestriction
 *         __nvmlDeviceSetAPIRestriction = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetAPIRestriction')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetAPIRestriction == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetAPIRestriction = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetAPIRestriction);

                /* "cuda/bindings/_internal/_nvml.pyx":1751
 *         global __nvmlDeviceSetAPIRestriction
 *         __nvmlDeviceSetAPIRestriction = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetAPIRestriction')
 *         if __nvmlDeviceSetAPIRestriction == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetAPIRestriction == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1752
 *         __nvmlDeviceSetAPIRestriction = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetAPIRestriction')
 *         if __nvmlDeviceSetAPIRestriction == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetAPIRestriction = dlsym(handle, 'nvmlDeviceSetAPIRestriction')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1753
 *         if __nvmlDeviceSetAPIRestriction == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetAPIRestriction = dlsym(handle, 'nvmlDeviceSetAPIRestriction')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1753, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1752
 *         __nvmlDeviceSetAPIRestriction = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetAPIRestriction')
 *         if __nvmlDeviceSetAPIRestriction == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetAPIRestriction = dlsym(handle, 'nvmlDeviceSetAPIRestriction')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1754
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetAPIRestriction = dlsym(handle, 'nvmlDeviceSetAPIRestriction')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetFanSpeed_v2
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetAPIRestriction = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetAPIRestriction);

                  /* "cuda/bindings/_internal/_nvml.pyx":1751
 *         global __nvmlDeviceSetAPIRestriction
 *         __nvmlDeviceSetAPIRestriction = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetAPIRestriction')
 *         if __nvmlDeviceSetAPIRestriction == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1757
 * 
 *         global __nvmlDeviceSetFanSpeed_v2
 *         __nvmlDeviceSetFanSpeed_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetFanSpeed_v2')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetFanSpeed_v2 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetFanSpeed_v2 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetFanSpeed_v2);

                /* "cuda/bindings/_internal/_nvml.pyx":1758
 *         global __nvmlDeviceSetFanSpeed_v2
 *         __nvmlDeviceSetFanSpeed_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetFanSpeed_v2')
 *         if __nvmlDeviceSetFanSpeed_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetFanSpeed_v2 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1759
 *         __nvmlDeviceSetFanSpeed_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetFanSpeed_v2')
 *         if __nvmlDeviceSetFanSpeed_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetFanSpeed_v2 = dlsym(handle, 'nvmlDeviceSetFanSpeed_v2')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1760
 *         if __nvmlDeviceSetFanSpeed_v2 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetFanSpeed_v2 = dlsym(handle, 'nvmlDeviceSetFanSpeed_v2')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1760, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1759
 *         __nvmlDeviceSetFanSpeed_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetFanSpeed_v2')
 *         if __nvmlDeviceSetFanSpeed_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetFanSpeed_v2 = dlsym(handle, 'nvmlDeviceSetFanSpeed_v2')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1761
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetFanSpeed_v2 = dlsym(handle, 'nvmlDeviceSetFanSpeed_v2')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetAccountingMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetFanSpeed_v2 = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetFanSpeed_v2);

                  /* "cuda/bindings/_internal/_nvml.pyx":1758
 *         global __nvmlDeviceSetFanSpeed_v2
 *         __nvmlDeviceSetFanSpeed_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetFanSpeed_v2')
 *         if __nvmlDeviceSetFanSpeed_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1764
 * 
 *         global __nvmlDeviceSetAccountingMode
 *         __nvmlDeviceSetAccountingMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetAccountingMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetAccountingMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetAccountingMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetAccountingMode);

                /* "cuda/bindings/_internal/_nvml.pyx":1765
 *         global __nvmlDeviceSetAccountingMode
 *         __nvmlDeviceSetAccountingMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetAccountingMode')
 *         if __nvmlDeviceSetAccountingMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetAccountingMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1766
 *         __nvmlDeviceSetAccountingMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetAccountingMode')
 *         if __nvmlDeviceSetAccountingMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetAccountingMode = dlsym(handle, 'nvmlDeviceSetAccountingMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1767
 *         if __nvmlDeviceSetAccountingMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetAccountingMode = dlsym(handle, 'nvmlDeviceSetAccountingMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1767, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1766
 *         __nvmlDeviceSetAccountingMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetAccountingMode')
 *         if __nvmlDeviceSetAccountingMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetAccountingMode = dlsym(handle, 'nvmlDeviceSetAccountingMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1768
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetAccountingMode = dlsym(handle, 'nvmlDeviceSetAccountingMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceClearAccountingPids
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetAccountingMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetAccountingMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":1765
 *         global __nvmlDeviceSetAccountingMode
 *         __nvmlDeviceSetAccountingMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetAccountingMode')
 *         if __nvmlDeviceSetAccountingMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1771
 * 
 *         global __nvmlDeviceClearAccountingPids
 *         __nvmlDeviceClearAccountingPids = dlsym(RTLD_DEFAULT, 'nvmlDeviceClearAccountingPids')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceClearAccountingPids == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearAccountingPids = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceClearAccountingPids);

                /* "cuda/bindings/_internal/_nvml.pyx":1772
 *         global __nvmlDeviceClearAccountingPids
 *         __nvmlDeviceClearAccountingPids = dlsym(RTLD_DEFAULT, 'nvmlDeviceClearAccountingPids')
 *         if __nvmlDeviceClearAccountingPids == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearAccountingPids == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1773
 *         __nvmlDeviceClearAccountingPids = dlsym(RTLD_DEFAULT, 'nvmlDeviceClearAccountingPids')
 *         if __nvmlDeviceClearAccountingPids == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceClearAccountingPids = dlsym(handle, 'nvmlDeviceClearAccountingPids')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1774
 *         if __nvmlDeviceClearAccountingPids == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceClearAccountingPids = dlsym(handle, 'nvmlDeviceClearAccountingPids')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1774, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1773
 *         __nvmlDeviceClearAccountingPids = dlsym(RTLD_DEFAULT, 'nvmlDeviceClearAccountingPids')
 *         if __nvmlDeviceClearAccountingPids == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceClearAccountingPids = dlsym(handle, 'nvmlDeviceClearAccountingPids')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1775
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceClearAccountingPids = dlsym(handle, 'nvmlDeviceClearAccountingPids')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetPowerManagementLimit_v2
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearAccountingPids = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceClearAccountingPids);

                  /* "cuda/bindings/_internal/_nvml.pyx":1772
 *         global __nvmlDeviceClearAccountingPids
 *         __nvmlDeviceClearAccountingPids = dlsym(RTLD_DEFAULT, 'nvmlDeviceClearAccountingPids')
 *         if __nvmlDeviceClearAccountingPids == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1778
 * 
 *         global __nvmlDeviceSetPowerManagementLimit_v2
 *         __nvmlDeviceSetPowerManagementLimit_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetPowerManagementLimit_v2')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetPowerManagementLimit_v2 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPowerManagementLimit_v2 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetPowerManagementLimi_2);

                /* "cuda/bindings/_internal/_nvml.pyx":1779
 *         global __nvmlDeviceSetPowerManagementLimit_v2
 *         __nvmlDeviceSetPowerManagementLimit_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetPowerManagementLimit_v2')
 *         if __nvmlDeviceSetPowerManagementLimit_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPowerManagementLimit_v2 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1780
 *         __nvmlDeviceSetPowerManagementLimit_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetPowerManagementLimit_v2')
 *         if __nvmlDeviceSetPowerManagementLimit_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetPowerManagementLimit_v2 = dlsym(handle, 'nvmlDeviceSetPowerManagementLimit_v2')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1781
 *         if __nvmlDeviceSetPowerManagementLimit_v2 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetPowerManagementLimit_v2 = dlsym(handle, 'nvmlDeviceSetPowerManagementLimit_v2')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1781, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1780
 *         __nvmlDeviceSetPowerManagementLimit_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetPowerManagementLimit_v2')
 *         if __nvmlDeviceSetPowerManagementLimit_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetPowerManagementLimit_v2 = dlsym(handle, 'nvmlDeviceSetPowerManagementLimit_v2')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1782
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetPowerManagementLimit_v2 = dlsym(handle, 'nvmlDeviceSetPowerManagementLimit_v2')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetNvLinkState
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPowerManagementLimit_v2 = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetPowerManagementLimi_2);

                  /* "cuda/bindings/_internal/_nvml.pyx":1779
 *         global __nvmlDeviceSetPowerManagementLimit_v2
 *         __nvmlDeviceSetPowerManagementLimit_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetPowerManagementLimit_v2')
 *         if __nvmlDeviceSetPowerManagementLimit_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1785
 * 
 *         global __nvmlDeviceGetNvLinkState
 *         __nvmlDeviceGetNvLinkState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkState')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetNvLinkState == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkState = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetNvLinkState);

                /* "cuda/bindings/_internal/_nvml.pyx":1786
 *         global __nvmlDeviceGetNvLinkState
 *         __nvmlDeviceGetNvLinkState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkState')
 *         if __nvmlDeviceGetNvLinkState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkState == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1787
 *         __nvmlDeviceGetNvLinkState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkState')
 *         if __nvmlDeviceGetNvLinkState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetNvLinkState = dlsym(handle, 'nvmlDeviceGetNvLinkState')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1788
 *         if __nvmlDeviceGetNvLinkState == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetNvLinkState = dlsym(handle, 'nvmlDeviceGetNvLinkState')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1788, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1787
 *         __nvmlDeviceGetNvLinkState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkState')
 *         if __nvmlDeviceGetNvLinkState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetNvLinkState = dlsym(handle, 'nvmlDeviceGetNvLinkState')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1789
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetNvLinkState = dlsym(handle, 'nvmlDeviceGetNvLinkState')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetNvLinkVersion
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkState = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetNvLinkState);

                  /* "cuda/bindings/_internal/_nvml.pyx":1786
 *         global __nvmlDeviceGetNvLinkState
 *         __nvmlDeviceGetNvLinkState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkState')
 *         if __nvmlDeviceGetNvLinkState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1792
 * 
 *         global __nvmlDeviceGetNvLinkVersion
 *         __nvmlDeviceGetNvLinkVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkVersion')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetNvLinkVersion == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkVersion = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetNvLinkVersion);

                /* "cuda/bindings/_internal/_nvml.pyx":1793
 *         global __nvmlDeviceGetNvLinkVersion
 *         __nvmlDeviceGetNvLinkVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkVersion')
 *         if __nvmlDeviceGetNvLinkVersion == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkVersion == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1794
 *         __nvmlDeviceGetNvLinkVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkVersion')
 *         if __nvmlDeviceGetNvLinkVersion == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetNvLinkVersion = dlsym(handle, 'nvmlDeviceGetNvLinkVersion')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1795
 *         if __nvmlDeviceGetNvLinkVersion == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetNvLinkVersion = dlsym(handle, 'nvmlDeviceGetNvLinkVersion')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1795, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1794
 *         __nvmlDeviceGetNvLinkVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkVersion')
 *         if __nvmlDeviceGetNvLinkVersion == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetNvLinkVersion = dlsym(handle, 'nvmlDeviceGetNvLinkVersion')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1796
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetNvLinkVersion = dlsym(handle, 'nvmlDeviceGetNvLinkVersion')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetNvLinkCapability
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkVersion = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetNvLinkVersion);

                  /* "cuda/bindings/_internal/_nvml.pyx":1793
 *         global __nvmlDeviceGetNvLinkVersion
 *         __nvmlDeviceGetNvLinkVersion = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkVersion')
 *         if __nvmlDeviceGetNvLinkVersion == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1799
 * 
 *         global __nvmlDeviceGetNvLinkCapability
 *         __nvmlDeviceGetNvLinkCapability = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkCapability')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetNvLinkCapability == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkCapability = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetNvLinkCapability);

                /* "cuda/bindings/_internal/_nvml.pyx":1800
 *         global __nvmlDeviceGetNvLinkCapability
 *         __nvmlDeviceGetNvLinkCapability = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkCapability')
 *         if __nvmlDeviceGetNvLinkCapability == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkCapability == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1801
 *         __nvmlDeviceGetNvLinkCapability = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkCapability')
 *         if __nvmlDeviceGetNvLinkCapability == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetNvLinkCapability = dlsym(handle, 'nvmlDeviceGetNvLinkCapability')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1802
 *         if __nvmlDeviceGetNvLinkCapability == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetNvLinkCapability = dlsym(handle, 'nvmlDeviceGetNvLinkCapability')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1802, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1801
 *         __nvmlDeviceGetNvLinkCapability = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkCapability')
 *         if __nvmlDeviceGetNvLinkCapability == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetNvLinkCapability = dlsym(handle, 'nvmlDeviceGetNvLinkCapability')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1803
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetNvLinkCapability = dlsym(handle, 'nvmlDeviceGetNvLinkCapability')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetNvLinkRemotePciInfo_v2
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkCapability = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetNvLinkCapability);

                  /* "cuda/bindings/_internal/_nvml.pyx":1800
 *         global __nvmlDeviceGetNvLinkCapability
 *         __nvmlDeviceGetNvLinkCapability = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkCapability')
 *         if __nvmlDeviceGetNvLinkCapability == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1806
 * 
 *         global __nvmlDeviceGetNvLinkRemotePciInfo_v2
 *         __nvmlDeviceGetNvLinkRemotePciInfo_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkRemotePciInfo_v2')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetNvLinkRemotePciInfo_v2 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkRemotePciInfo_v2 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetNvLinkRemotePciInfo);

                /* "cuda/bindings/_internal/_nvml.pyx":1807
 *         global __nvmlDeviceGetNvLinkRemotePciInfo_v2
 *         __nvmlDeviceGetNvLinkRemotePciInfo_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkRemotePciInfo_v2')
 *         if __nvmlDeviceGetNvLinkRemotePciInfo_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkRemotePciInfo_v2 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1808
 *         __nvmlDeviceGetNvLinkRemotePciInfo_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkRemotePciInfo_v2')
 *         if __nvmlDeviceGetNvLinkRemotePciInfo_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetNvLinkRemotePciInfo_v2 = dlsym(handle, 'nvmlDeviceGetNvLinkRemotePciInfo_v2')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1809
 *         if __nvmlDeviceGetNvLinkRemotePciInfo_v2 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetNvLinkRemotePciInfo_v2 = dlsym(handle, 'nvmlDeviceGetNvLinkRemotePciInfo_v2')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1809, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1808
 *         __nvmlDeviceGetNvLinkRemotePciInfo_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkRemotePciInfo_v2')
 *         if __nvmlDeviceGetNvLinkRemotePciInfo_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetNvLinkRemotePciInfo_v2 = dlsym(handle, 'nvmlDeviceGetNvLinkRemotePciInfo_v2')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1810
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetNvLinkRemotePciInfo_v2 = dlsym(handle, 'nvmlDeviceGetNvLinkRemotePciInfo_v2')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetNvLinkErrorCounter
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkRemotePciInfo_v2 = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetNvLinkRemotePciInfo);

                  /* "cuda/bindings/_internal/_nvml.pyx":1807
 *         global __nvmlDeviceGetNvLinkRemotePciInfo_v2
 *         __nvmlDeviceGetNvLinkRemotePciInfo_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkRemotePciInfo_v2')
 *         if __nvmlDeviceGetNvLinkRemotePciInfo_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1813
 * 
 *         global __nvmlDeviceGetNvLinkErrorCounter
 *         __nvmlDeviceGetNvLinkErrorCounter = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkErrorCounter')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetNvLinkErrorCounter == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkErrorCounter = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetNvLinkErrorCounter);

                /* "cuda/bindings/_internal/_nvml.pyx":1814
 *         global __nvmlDeviceGetNvLinkErrorCounter
 *         __nvmlDeviceGetNvLinkErrorCounter = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkErrorCounter')
 *         if __nvmlDeviceGetNvLinkErrorCounter == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkErrorCounter == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1815
 *         __nvmlDeviceGetNvLinkErrorCounter = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkErrorCounter')
 *         if __nvmlDeviceGetNvLinkErrorCounter == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetNvLinkErrorCounter = dlsym(handle, 'nvmlDeviceGetNvLinkErrorCounter')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1816
 *         if __nvmlDeviceGetNvLinkErrorCounter == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetNvLinkErrorCounter = dlsym(handle, 'nvmlDeviceGetNvLinkErrorCounter')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1816, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1815
 *         __nvmlDeviceGetNvLinkErrorCounter = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkErrorCounter')
 *         if __nvmlDeviceGetNvLinkErrorCounter == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetNvLinkErrorCounter = dlsym(handle, 'nvmlDeviceGetNvLinkErrorCounter')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1817
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetNvLinkErrorCounter = dlsym(handle, 'nvmlDeviceGetNvLinkErrorCounter')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceResetNvLinkErrorCounters
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkErrorCounter = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetNvLinkErrorCounter);

                  /* "cuda/bindings/_internal/_nvml.pyx":1814
 *         global __nvmlDeviceGetNvLinkErrorCounter
 *         __nvmlDeviceGetNvLinkErrorCounter = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkErrorCounter')
 *         if __nvmlDeviceGetNvLinkErrorCounter == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1820
 * 
 *         global __nvmlDeviceResetNvLinkErrorCounters
 *         __nvmlDeviceResetNvLinkErrorCounters = dlsym(RTLD_DEFAULT, 'nvmlDeviceResetNvLinkErrorCounters')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceResetNvLinkErrorCounters == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceResetNvLinkErrorCounters = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceResetNvLinkErrorCounte);

                /* "cuda/bindings/_internal/_nvml.pyx":1821
 *         global __nvmlDeviceResetNvLinkErrorCounters
 *         __nvmlDeviceResetNvLinkErrorCounters = dlsym(RTLD_DEFAULT, 'nvmlDeviceResetNvLinkErrorCounters')
 *         if __nvmlDeviceResetNvLinkErrorCounters == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceResetNvLinkErrorCounters == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1822
 *         __nvmlDeviceResetNvLinkErrorCounters = dlsym(RTLD_DEFAULT, 'nvmlDeviceResetNvLinkErrorCounters')
 *         if __nvmlDeviceResetNvLinkErrorCounters == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceResetNvLinkErrorCounters = dlsym(handle, 'nvmlDeviceResetNvLinkErrorCounters')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1823
 *         if __nvmlDeviceResetNvLinkErrorCounters == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceResetNvLinkErrorCounters = dlsym(handle, 'nvmlDeviceResetNvLinkErrorCounters')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1823, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1822
 *         __nvmlDeviceResetNvLinkErrorCounters = dlsym(RTLD_DEFAULT, 'nvmlDeviceResetNvLinkErrorCounters')
 *         if __nvmlDeviceResetNvLinkErrorCounters == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceResetNvLinkErrorCounters = dlsym(handle, 'nvmlDeviceResetNvLinkErrorCounters')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1824
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceResetNvLinkErrorCounters = dlsym(handle, 'nvmlDeviceResetNvLinkErrorCounters')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetNvLinkRemoteDeviceType
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceResetNvLinkErrorCounters = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceResetNvLinkErrorCounte);

                  /* "cuda/bindings/_internal/_nvml.pyx":1821
 *         global __nvmlDeviceResetNvLinkErrorCounters
 *         __nvmlDeviceResetNvLinkErrorCounters = dlsym(RTLD_DEFAULT, 'nvmlDeviceResetNvLinkErrorCounters')
 *         if __nvmlDeviceResetNvLinkErrorCounters == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1827
 * 
 *         global __nvmlDeviceGetNvLinkRemoteDeviceType
 *         __nvmlDeviceGetNvLinkRemoteDeviceType = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkRemoteDeviceType')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetNvLinkRemoteDeviceType == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkRemoteDeviceType = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetNvLinkRemoteDeviceT);

                /* "cuda/bindings/_internal/_nvml.pyx":1828
 *         global __nvmlDeviceGetNvLinkRemoteDeviceType
 *         __nvmlDeviceGetNvLinkRemoteDeviceType = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkRemoteDeviceType')
 *         if __nvmlDeviceGetNvLinkRemoteDeviceType == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkRemoteDeviceType == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1829
 *         __nvmlDeviceGetNvLinkRemoteDeviceType = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkRemoteDeviceType')
 *         if __nvmlDeviceGetNvLinkRemoteDeviceType == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetNvLinkRemoteDeviceType = dlsym(handle, 'nvmlDeviceGetNvLinkRemoteDeviceType')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1830
 *         if __nvmlDeviceGetNvLinkRemoteDeviceType == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetNvLinkRemoteDeviceType = dlsym(handle, 'nvmlDeviceGetNvLinkRemoteDeviceType')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1830, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1829
 *         __nvmlDeviceGetNvLinkRemoteDeviceType = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkRemoteDeviceType')
 *         if __nvmlDeviceGetNvLinkRemoteDeviceType == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetNvLinkRemoteDeviceType = dlsym(handle, 'nvmlDeviceGetNvLinkRemoteDeviceType')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1831
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetNvLinkRemoteDeviceType = dlsym(handle, 'nvmlDeviceGetNvLinkRemoteDeviceType')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetNvLinkDeviceLowPowerThreshold
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkRemoteDeviceType = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetNvLinkRemoteDeviceT);

                  /* "cuda/bindings/_internal/_nvml.pyx":1828
 *         global __nvmlDeviceGetNvLinkRemoteDeviceType
 *         __nvmlDeviceGetNvLinkRemoteDeviceType = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkRemoteDeviceType')
 *         if __nvmlDeviceGetNvLinkRemoteDeviceType == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1834
 * 
 *         global __nvmlDeviceSetNvLinkDeviceLowPowerThreshold
 *         __nvmlDeviceSetNvLinkDeviceLowPowerThreshold = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetNvLinkDeviceLowPowerThreshold')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetNvLinkDeviceLowPowerThreshold == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetNvLinkDeviceLowPowerThreshold = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetNvLinkDeviceLowPowe);

                /* "cuda/bindings/_internal/_nvml.pyx":1835
 *         global __nvmlDeviceSetNvLinkDeviceLowPowerThreshold
 *         __nvmlDeviceSetNvLinkDeviceLowPowerThreshold = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetNvLinkDeviceLowPowerThreshold')
 *         if __nvmlDeviceSetNvLinkDeviceLowPowerThreshold == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetNvLinkDeviceLowPowerThreshold == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1836
 *         __nvmlDeviceSetNvLinkDeviceLowPowerThreshold = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetNvLinkDeviceLowPowerThreshold')
 *         if __nvmlDeviceSetNvLinkDeviceLowPowerThreshold == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetNvLinkDeviceLowPowerThreshold = dlsym(handle, 'nvmlDeviceSetNvLinkDeviceLowPowerThreshold')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1837
 *         if __nvmlDeviceSetNvLinkDeviceLowPowerThreshold == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetNvLinkDeviceLowPowerThreshold = dlsym(handle, 'nvmlDeviceSetNvLinkDeviceLowPowerThreshold')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1837, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1836
 *         __nvmlDeviceSetNvLinkDeviceLowPowerThreshold = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetNvLinkDeviceLowPowerThreshold')
 *         if __nvmlDeviceSetNvLinkDeviceLowPowerThreshold == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetNvLinkDeviceLowPowerThreshold = dlsym(handle, 'nvmlDeviceSetNvLinkDeviceLowPowerThreshold')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1838
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetNvLinkDeviceLowPowerThreshold = dlsym(handle, 'nvmlDeviceSetNvLinkDeviceLowPowerThreshold')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlSystemSetNvlinkBwMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetNvLinkDeviceLowPowerThreshold = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetNvLinkDeviceLowPowe);

                  /* "cuda/bindings/_internal/_nvml.pyx":1835
 *         global __nvmlDeviceSetNvLinkDeviceLowPowerThreshold
 *         __nvmlDeviceSetNvLinkDeviceLowPowerThreshold = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetNvLinkDeviceLowPowerThreshold')
 *         if __nvmlDeviceSetNvLinkDeviceLowPowerThreshold == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1841
 * 
 *         global __nvmlSystemSetNvlinkBwMode
 *         __nvmlSystemSetNvlinkBwMode = dlsym(RTLD_DEFAULT, 'nvmlSystemSetNvlinkBwMode')             # <<<<<<<<<<<<<<
 *         if __nvmlSystemSetNvlinkBwMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemSetNvlinkBwMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlSystemSetNvlinkBwMode);

                /* "cuda/bindings/_internal/_nvml.pyx":1842
 *         global __nvmlSystemSetNvlinkBwMode
 *         __nvmlSystemSetNvlinkBwMode = dlsym(RTLD_DEFAULT, 'nvmlSystemSetNvlinkBwMode')
 *         if __nvmlSystemSetNvlinkBwMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemSetNvlinkBwMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1843
 *         __nvmlSystemSetNvlinkBwMode = dlsym(RTLD_DEFAULT, 'nvmlSystemSetNvlinkBwMode')
 *         if __nvmlSystemSetNvlinkBwMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemSetNvlinkBwMode = dlsym(handle, 'nvmlSystemSetNvlinkBwMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1844
 *         if __nvmlSystemSetNvlinkBwMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlSystemSetNvlinkBwMode = dlsym(handle, 'nvmlSystemSetNvlinkBwMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1844, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1843
 *         __nvmlSystemSetNvlinkBwMode = dlsym(RTLD_DEFAULT, 'nvmlSystemSetNvlinkBwMode')
 *         if __nvmlSystemSetNvlinkBwMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemSetNvlinkBwMode = dlsym(handle, 'nvmlSystemSetNvlinkBwMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1845
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlSystemSetNvlinkBwMode = dlsym(handle, 'nvmlSystemSetNvlinkBwMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlSystemGetNvlinkBwMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemSetNvlinkBwMode = dlsym(__pyx_v_handle, __pyx_k_nvmlSystemSetNvlinkBwMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":1842
 *         global __nvmlSystemSetNvlinkBwMode
 *         __nvmlSystemSetNvlinkBwMode = dlsym(RTLD_DEFAULT, 'nvmlSystemSetNvlinkBwMode')
 *         if __nvmlSystemSetNvlinkBwMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1848
 * 
 *         global __nvmlSystemGetNvlinkBwMode
 *         __nvmlSystemGetNvlinkBwMode = dlsym(RTLD_DEFAULT, 'nvmlSystemGetNvlinkBwMode')             # <<<<<<<<<<<<<<
 *         if __nvmlSystemGetNvlinkBwMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetNvlinkBwMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlSystemGetNvlinkBwMode);

                /* "cuda/bindings/_internal/_nvml.pyx":1849
 *         global __nvmlSystemGetNvlinkBwMode
 *         __nvmlSystemGetNvlinkBwMode = dlsym(RTLD_DEFAULT, 'nvmlSystemGetNvlinkBwMode')
 *         if __nvmlSystemGetNvlinkBwMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetNvlinkBwMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1850
 *         __nvmlSystemGetNvlinkBwMode = dlsym(RTLD_DEFAULT, 'nvmlSystemGetNvlinkBwMode')
 *         if __nvmlSystemGetNvlinkBwMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetNvlinkBwMode = dlsym(handle, 'nvmlSystemGetNvlinkBwMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1851
 *         if __nvmlSystemGetNvlinkBwMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlSystemGetNvlinkBwMode = dlsym(handle, 'nvmlSystemGetNvlinkBwMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1851, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1850
 *         __nvmlSystemGetNvlinkBwMode = dlsym(RTLD_DEFAULT, 'nvmlSystemGetNvlinkBwMode')
 *         if __nvmlSystemGetNvlinkBwMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemGetNvlinkBwMode = dlsym(handle, 'nvmlSystemGetNvlinkBwMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1852
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlSystemGetNvlinkBwMode = dlsym(handle, 'nvmlSystemGetNvlinkBwMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetNvlinkSupportedBwModes
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetNvlinkBwMode = dlsym(__pyx_v_handle, __pyx_k_nvmlSystemGetNvlinkBwMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":1849
 *         global __nvmlSystemGetNvlinkBwMode
 *         __nvmlSystemGetNvlinkBwMode = dlsym(RTLD_DEFAULT, 'nvmlSystemGetNvlinkBwMode')
 *         if __nvmlSystemGetNvlinkBwMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1855
 * 
 *         global __nvmlDeviceGetNvlinkSupportedBwModes
 *         __nvmlDeviceGetNvlinkSupportedBwModes = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvlinkSupportedBwModes')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetNvlinkSupportedBwModes == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvlinkSupportedBwModes = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetNvlinkSupportedBwMo);

                /* "cuda/bindings/_internal/_nvml.pyx":1856
 *         global __nvmlDeviceGetNvlinkSupportedBwModes
 *         __nvmlDeviceGetNvlinkSupportedBwModes = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvlinkSupportedBwModes')
 *         if __nvmlDeviceGetNvlinkSupportedBwModes == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvlinkSupportedBwModes == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1857
 *         __nvmlDeviceGetNvlinkSupportedBwModes = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvlinkSupportedBwModes')
 *         if __nvmlDeviceGetNvlinkSupportedBwModes == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetNvlinkSupportedBwModes = dlsym(handle, 'nvmlDeviceGetNvlinkSupportedBwModes')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1858
 *         if __nvmlDeviceGetNvlinkSupportedBwModes == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetNvlinkSupportedBwModes = dlsym(handle, 'nvmlDeviceGetNvlinkSupportedBwModes')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1858, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1857
 *         __nvmlDeviceGetNvlinkSupportedBwModes = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvlinkSupportedBwModes')
 *         if __nvmlDeviceGetNvlinkSupportedBwModes == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetNvlinkSupportedBwModes = dlsym(handle, 'nvmlDeviceGetNvlinkSupportedBwModes')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1859
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetNvlinkSupportedBwModes = dlsym(handle, 'nvmlDeviceGetNvlinkSupportedBwModes')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetNvlinkBwMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvlinkSupportedBwModes = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetNvlinkSupportedBwMo);

                  /* "cuda/bindings/_internal/_nvml.pyx":1856
 *         global __nvmlDeviceGetNvlinkSupportedBwModes
 *         __nvmlDeviceGetNvlinkSupportedBwModes = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvlinkSupportedBwModes')
 *         if __nvmlDeviceGetNvlinkSupportedBwModes == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1862
 * 
 *         global __nvmlDeviceGetNvlinkBwMode
 *         __nvmlDeviceGetNvlinkBwMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvlinkBwMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetNvlinkBwMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvlinkBwMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetNvlinkBwMode);

                /* "cuda/bindings/_internal/_nvml.pyx":1863
 *         global __nvmlDeviceGetNvlinkBwMode
 *         __nvmlDeviceGetNvlinkBwMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvlinkBwMode')
 *         if __nvmlDeviceGetNvlinkBwMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvlinkBwMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1864
 *         __nvmlDeviceGetNvlinkBwMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvlinkBwMode')
 *         if __nvmlDeviceGetNvlinkBwMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetNvlinkBwMode = dlsym(handle, 'nvmlDeviceGetNvlinkBwMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1865
 *         if __nvmlDeviceGetNvlinkBwMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetNvlinkBwMode = dlsym(handle, 'nvmlDeviceGetNvlinkBwMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1865, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1864
 *         __nvmlDeviceGetNvlinkBwMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvlinkBwMode')
 *         if __nvmlDeviceGetNvlinkBwMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetNvlinkBwMode = dlsym(handle, 'nvmlDeviceGetNvlinkBwMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1866
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetNvlinkBwMode = dlsym(handle, 'nvmlDeviceGetNvlinkBwMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetNvlinkBwMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvlinkBwMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetNvlinkBwMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":1863
 *         global __nvmlDeviceGetNvlinkBwMode
 *         __nvmlDeviceGetNvlinkBwMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvlinkBwMode')
 *         if __nvmlDeviceGetNvlinkBwMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1869
 * 
 *         global __nvmlDeviceSetNvlinkBwMode
 *         __nvmlDeviceSetNvlinkBwMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetNvlinkBwMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetNvlinkBwMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetNvlinkBwMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetNvlinkBwMode);

                /* "cuda/bindings/_internal/_nvml.pyx":1870
 *         global __nvmlDeviceSetNvlinkBwMode
 *         __nvmlDeviceSetNvlinkBwMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetNvlinkBwMode')
 *         if __nvmlDeviceSetNvlinkBwMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetNvlinkBwMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1871
 *         __nvmlDeviceSetNvlinkBwMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetNvlinkBwMode')
 *         if __nvmlDeviceSetNvlinkBwMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetNvlinkBwMode = dlsym(handle, 'nvmlDeviceSetNvlinkBwMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1872
 *         if __nvmlDeviceSetNvlinkBwMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetNvlinkBwMode = dlsym(handle, 'nvmlDeviceSetNvlinkBwMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1872, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1871
 *         __nvmlDeviceSetNvlinkBwMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetNvlinkBwMode')
 *         if __nvmlDeviceSetNvlinkBwMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetNvlinkBwMode = dlsym(handle, 'nvmlDeviceSetNvlinkBwMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1873
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetNvlinkBwMode = dlsym(handle, 'nvmlDeviceSetNvlinkBwMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlEventSetCreate
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetNvlinkBwMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetNvlinkBwMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":1870
 *         global __nvmlDeviceSetNvlinkBwMode
 *         __nvmlDeviceSetNvlinkBwMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetNvlinkBwMode')
 *         if __nvmlDeviceSetNvlinkBwMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1876
 * 
 *         global __nvmlEventSetCreate
 *         __nvmlEventSetCreate = dlsym(RTLD_DEFAULT, 'nvmlEventSetCreate')             # <<<<<<<<<<<<<<
 *         if __nvmlEventSetCreate == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlEventSetCreate = dlsym(RTLD_DEFAULT, __pyx_k_nvmlEventSetCreate);

                /* "cuda/bindings/_internal/_nvml.pyx":1877
 *         global __nvmlEventSetCreate
 *         __nvmlEventSetCreate = dlsym(RTLD_DEFAULT, 'nvmlEventSetCreate')
 *         if __nvmlEventSetCreate == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlEventSetCreate == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1878
 *         __nvmlEventSetCreate = dlsym(RTLD_DEFAULT, 'nvmlEventSetCreate')
 *         if __nvmlEventSetCreate == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlEventSetCreate = dlsym(handle, 'nvmlEventSetCreate')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1879
 *         if __nvmlEventSetCreate == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlEventSetCreate = dlsym(handle, 'nvmlEventSetCreate')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1879, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1878
 *         __nvmlEventSetCreate = dlsym(RTLD_DEFAULT, 'nvmlEventSetCreate')
 *         if __nvmlEventSetCreate == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlEventSetCreate = dlsym(handle, 'nvmlEventSetCreate')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1880
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlEventSetCreate = dlsym(handle, 'nvmlEventSetCreate')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceRegisterEvents
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlEventSetCreate = dlsym(__pyx_v_handle, __pyx_k_nvmlEventSetCreate);

                  /* "cuda/bindings/_internal/_nvml.pyx":1877
 *         global __nvmlEventSetCreate
 *         __nvmlEventSetCreate = dlsym(RTLD_DEFAULT, 'nvmlEventSetCreate')
 *         if __nvmlEventSetCreate == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1883
 * 
 *         global __nvmlDeviceRegisterEvents
 *         __nvmlDeviceRegisterEvents = dlsym(RTLD_DEFAULT, 'nvmlDeviceRegisterEvents')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceRegisterEvents == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceRegisterEvents = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceRegisterEvents);

                /* "cuda/bindings/_internal/_nvml.pyx":1884
 *         global __nvmlDeviceRegisterEvents
 *         __nvmlDeviceRegisterEvents = dlsym(RTLD_DEFAULT, 'nvmlDeviceRegisterEvents')
 *         if __nvmlDeviceRegisterEvents == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceRegisterEvents == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1885
 *         __nvmlDeviceRegisterEvents = dlsym(RTLD_DEFAULT, 'nvmlDeviceRegisterEvents')
 *         if __nvmlDeviceRegisterEvents == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceRegisterEvents = dlsym(handle, 'nvmlDeviceRegisterEvents')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1886
 *         if __nvmlDeviceRegisterEvents == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceRegisterEvents = dlsym(handle, 'nvmlDeviceRegisterEvents')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1886, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1885
 *         __nvmlDeviceRegisterEvents = dlsym(RTLD_DEFAULT, 'nvmlDeviceRegisterEvents')
 *         if __nvmlDeviceRegisterEvents == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceRegisterEvents = dlsym(handle, 'nvmlDeviceRegisterEvents')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1887
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceRegisterEvents = dlsym(handle, 'nvmlDeviceRegisterEvents')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetSupportedEventTypes
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceRegisterEvents = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceRegisterEvents);

                  /* "cuda/bindings/_internal/_nvml.pyx":1884
 *         global __nvmlDeviceRegisterEvents
 *         __nvmlDeviceRegisterEvents = dlsym(RTLD_DEFAULT, 'nvmlDeviceRegisterEvents')
 *         if __nvmlDeviceRegisterEvents == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1890
 * 
 *         global __nvmlDeviceGetSupportedEventTypes
 *         __nvmlDeviceGetSupportedEventTypes = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedEventTypes')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetSupportedEventTypes == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedEventTypes = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetSupportedEventTypes);

                /* "cuda/bindings/_internal/_nvml.pyx":1891
 *         global __nvmlDeviceGetSupportedEventTypes
 *         __nvmlDeviceGetSupportedEventTypes = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedEventTypes')
 *         if __nvmlDeviceGetSupportedEventTypes == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedEventTypes == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1892
 *         __nvmlDeviceGetSupportedEventTypes = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedEventTypes')
 *         if __nvmlDeviceGetSupportedEventTypes == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetSupportedEventTypes = dlsym(handle, 'nvmlDeviceGetSupportedEventTypes')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1893
 *         if __nvmlDeviceGetSupportedEventTypes == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetSupportedEventTypes = dlsym(handle, 'nvmlDeviceGetSupportedEventTypes')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1893, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1892
 *         __nvmlDeviceGetSupportedEventTypes = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedEventTypes')
 *         if __nvmlDeviceGetSupportedEventTypes == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetSupportedEventTypes = dlsym(handle, 'nvmlDeviceGetSupportedEventTypes')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1894
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetSupportedEventTypes = dlsym(handle, 'nvmlDeviceGetSupportedEventTypes')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlEventSetWait_v2
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedEventTypes = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetSupportedEventTypes);

                  /* "cuda/bindings/_internal/_nvml.pyx":1891
 *         global __nvmlDeviceGetSupportedEventTypes
 *         __nvmlDeviceGetSupportedEventTypes = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedEventTypes')
 *         if __nvmlDeviceGetSupportedEventTypes == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1897
 * 
 *         global __nvmlEventSetWait_v2
 *         __nvmlEventSetWait_v2 = dlsym(RTLD_DEFAULT, 'nvmlEventSetWait_v2')             # <<<<<<<<<<<<<<
 *         if __nvmlEventSetWait_v2 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlEventSetWait_v2 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlEventSetWait_v2);

                /* "cuda/bindings/_internal/_nvml.pyx":1898
 *         global __nvmlEventSetWait_v2
 *         __nvmlEventSetWait_v2 = dlsym(RTLD_DEFAULT, 'nvmlEventSetWait_v2')
 *         if __nvmlEventSetWait_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlEventSetWait_v2 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1899
 *         __nvmlEventSetWait_v2 = dlsym(RTLD_DEFAULT, 'nvmlEventSetWait_v2')
 *         if __nvmlEventSetWait_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlEventSetWait_v2 = dlsym(handle, 'nvmlEventSetWait_v2')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1900
 *         if __nvmlEventSetWait_v2 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlEventSetWait_v2 = dlsym(handle, 'nvmlEventSetWait_v2')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1900, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1899
 *         __nvmlEventSetWait_v2 = dlsym(RTLD_DEFAULT, 'nvmlEventSetWait_v2')
 *         if __nvmlEventSetWait_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlEventSetWait_v2 = dlsym(handle, 'nvmlEventSetWait_v2')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1901
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlEventSetWait_v2 = dlsym(handle, 'nvmlEventSetWait_v2')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlEventSetFree
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlEventSetWait_v2 = dlsym(__pyx_v_handle, __pyx_k_nvmlEventSetWait_v2);

                  /* "cuda/bindings/_internal/_nvml.pyx":1898
 *         global __nvmlEventSetWait_v2
 *         __nvmlEventSetWait_v2 = dlsym(RTLD_DEFAULT, 'nvmlEventSetWait_v2')
 *         if __nvmlEventSetWait_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1904
 * 
 *         global __nvmlEventSetFree
 *         __nvmlEventSetFree = dlsym(RTLD_DEFAULT, 'nvmlEventSetFree')             # <<<<<<<<<<<<<<
 *         if __nvmlEventSetFree == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlEventSetFree = dlsym(RTLD_DEFAULT, __pyx_k_nvmlEventSetFree);

                /* "cuda/bindings/_internal/_nvml.pyx":1905
 *         global __nvmlEventSetFree
 *         __nvmlEventSetFree = dlsym(RTLD_DEFAULT, 'nvmlEventSetFree')
 *         if __nvmlEventSetFree == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlEventSetFree == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1906
 *         __nvmlEventSetFree = dlsym(RTLD_DEFAULT, 'nvmlEventSetFree')
 *         if __nvmlEventSetFree == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlEventSetFree = dlsym(handle, 'nvmlEventSetFree')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1907
 *         if __nvmlEventSetFree == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlEventSetFree = dlsym(handle, 'nvmlEventSetFree')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1907, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1906
 *         __nvmlEventSetFree = dlsym(RTLD_DEFAULT, 'nvmlEventSetFree')
 *         if __nvmlEventSetFree == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlEventSetFree = dlsym(handle, 'nvmlEventSetFree')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1908
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlEventSetFree = dlsym(handle, 'nvmlEventSetFree')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlSystemEventSetCreate
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlEventSetFree = dlsym(__pyx_v_handle, __pyx_k_nvmlEventSetFree);

                  /* "cuda/bindings/_internal/_nvml.pyx":1905
 *         global __nvmlEventSetFree
 *         __nvmlEventSetFree = dlsym(RTLD_DEFAULT, 'nvmlEventSetFree')
 *         if __nvmlEventSetFree == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1911
 * 
 *         global __nvmlSystemEventSetCreate
 *         __nvmlSystemEventSetCreate = dlsym(RTLD_DEFAULT, 'nvmlSystemEventSetCreate')             # <<<<<<<<<<<<<<
 *         if __nvmlSystemEventSetCreate == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemEventSetCreate = dlsym(RTLD_DEFAULT, __pyx_k_nvmlSystemEventSetCreate);

                /* "cuda/bindings/_internal/_nvml.pyx":1912
 *         global __nvmlSystemEventSetCreate
 *         __nvmlSystemEventSetCreate = dlsym(RTLD_DEFAULT, 'nvmlSystemEventSetCreate')
 *         if __nvmlSystemEventSetCreate == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemEventSetCreate == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1913
 *         __nvmlSystemEventSetCreate = dlsym(RTLD_DEFAULT, 'nvmlSystemEventSetCreate')
 *         if __nvmlSystemEventSetCreate == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemEventSetCreate = dlsym(handle, 'nvmlSystemEventSetCreate')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1914
 *         if __nvmlSystemEventSetCreate == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlSystemEventSetCreate = dlsym(handle, 'nvmlSystemEventSetCreate')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1914, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1913
 *         __nvmlSystemEventSetCreate = dlsym(RTLD_DEFAULT, 'nvmlSystemEventSetCreate')
 *         if __nvmlSystemEventSetCreate == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemEventSetCreate = dlsym(handle, 'nvmlSystemEventSetCreate')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1915
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlSystemEventSetCreate = dlsym(handle, 'nvmlSystemEventSetCreate')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlSystemEventSetFree
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemEventSetCreate = dlsym(__pyx_v_handle, __pyx_k_nvmlSystemEventSetCreate);

                  /* "cuda/bindings/_internal/_nvml.pyx":1912
 *         global __nvmlSystemEventSetCreate
 *         __nvmlSystemEventSetCreate = dlsym(RTLD_DEFAULT, 'nvmlSystemEventSetCreate')
 *         if __nvmlSystemEventSetCreate == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1918
 * 
 *         global __nvmlSystemEventSetFree
 *         __nvmlSystemEventSetFree = dlsym(RTLD_DEFAULT, 'nvmlSystemEventSetFree')             # <<<<<<<<<<<<<<
 *         if __nvmlSystemEventSetFree == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemEventSetFree = dlsym(RTLD_DEFAULT, __pyx_k_nvmlSystemEventSetFree);

                /* "cuda/bindings/_internal/_nvml.pyx":1919
 *         global __nvmlSystemEventSetFree
 *         __nvmlSystemEventSetFree = dlsym(RTLD_DEFAULT, 'nvmlSystemEventSetFree')
 *         if __nvmlSystemEventSetFree == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemEventSetFree == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1920
 *         __nvmlSystemEventSetFree = dlsym(RTLD_DEFAULT, 'nvmlSystemEventSetFree')
 *         if __nvmlSystemEventSetFree == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemEventSetFree = dlsym(handle, 'nvmlSystemEventSetFree')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1921
 *         if __nvmlSystemEventSetFree == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlSystemEventSetFree = dlsym(handle, 'nvmlSystemEventSetFree')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1921, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1920
 *         __nvmlSystemEventSetFree = dlsym(RTLD_DEFAULT, 'nvmlSystemEventSetFree')
 *         if __nvmlSystemEventSetFree == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemEventSetFree = dlsym(handle, 'nvmlSystemEventSetFree')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1922
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlSystemEventSetFree = dlsym(handle, 'nvmlSystemEventSetFree')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlSystemRegisterEvents
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemEventSetFree = dlsym(__pyx_v_handle, __pyx_k_nvmlSystemEventSetFree);

                  /* "cuda/bindings/_internal/_nvml.pyx":1919
 *         global __nvmlSystemEventSetFree
 *         __nvmlSystemEventSetFree = dlsym(RTLD_DEFAULT, 'nvmlSystemEventSetFree')
 *         if __nvmlSystemEventSetFree == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1925
 * 
 *         global __nvmlSystemRegisterEvents
 *         __nvmlSystemRegisterEvents = dlsym(RTLD_DEFAULT, 'nvmlSystemRegisterEvents')             # <<<<<<<<<<<<<<
 *         if __nvmlSystemRegisterEvents == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemRegisterEvents = dlsym(RTLD_DEFAULT, __pyx_k_nvmlSystemRegisterEvents);

                /* "cuda/bindings/_internal/_nvml.pyx":1926
 *         global __nvmlSystemRegisterEvents
 *         __nvmlSystemRegisterEvents = dlsym(RTLD_DEFAULT, 'nvmlSystemRegisterEvents')
 *         if __nvmlSystemRegisterEvents == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemRegisterEvents == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1927
 *         __nvmlSystemRegisterEvents = dlsym(RTLD_DEFAULT, 'nvmlSystemRegisterEvents')
 *         if __nvmlSystemRegisterEvents == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemRegisterEvents = dlsym(handle, 'nvmlSystemRegisterEvents')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1928
 *         if __nvmlSystemRegisterEvents == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlSystemRegisterEvents = dlsym(handle, 'nvmlSystemRegisterEvents')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1928, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1927
 *         __nvmlSystemRegisterEvents = dlsym(RTLD_DEFAULT, 'nvmlSystemRegisterEvents')
 *         if __nvmlSystemRegisterEvents == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemRegisterEvents = dlsym(handle, 'nvmlSystemRegisterEvents')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1929
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlSystemRegisterEvents = dlsym(handle, 'nvmlSystemRegisterEvents')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlSystemEventSetWait
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemRegisterEvents = dlsym(__pyx_v_handle, __pyx_k_nvmlSystemRegisterEvents);

                  /* "cuda/bindings/_internal/_nvml.pyx":1926
 *         global __nvmlSystemRegisterEvents
 *         __nvmlSystemRegisterEvents = dlsym(RTLD_DEFAULT, 'nvmlSystemRegisterEvents')
 *         if __nvmlSystemRegisterEvents == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1932
 * 
 *         global __nvmlSystemEventSetWait
 *         __nvmlSystemEventSetWait = dlsym(RTLD_DEFAULT, 'nvmlSystemEventSetWait')             # <<<<<<<<<<<<<<
 *         if __nvmlSystemEventSetWait == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemEventSetWait = dlsym(RTLD_DEFAULT, __pyx_k_nvmlSystemEventSetWait);

                /* "cuda/bindings/_internal/_nvml.pyx":1933
 *         global __nvmlSystemEventSetWait
 *         __nvmlSystemEventSetWait = dlsym(RTLD_DEFAULT, 'nvmlSystemEventSetWait')
 *         if __nvmlSystemEventSetWait == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemEventSetWait == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1934
 *         __nvmlSystemEventSetWait = dlsym(RTLD_DEFAULT, 'nvmlSystemEventSetWait')
 *         if __nvmlSystemEventSetWait == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemEventSetWait = dlsym(handle, 'nvmlSystemEventSetWait')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1935
 *         if __nvmlSystemEventSetWait == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlSystemEventSetWait = dlsym(handle, 'nvmlSystemEventSetWait')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1935, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1934
 *         __nvmlSystemEventSetWait = dlsym(RTLD_DEFAULT, 'nvmlSystemEventSetWait')
 *         if __nvmlSystemEventSetWait == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSystemEventSetWait = dlsym(handle, 'nvmlSystemEventSetWait')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1936
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlSystemEventSetWait = dlsym(handle, 'nvmlSystemEventSetWait')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceModifyDrainState
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemEventSetWait = dlsym(__pyx_v_handle, __pyx_k_nvmlSystemEventSetWait);

                  /* "cuda/bindings/_internal/_nvml.pyx":1933
 *         global __nvmlSystemEventSetWait
 *         __nvmlSystemEventSetWait = dlsym(RTLD_DEFAULT, 'nvmlSystemEventSetWait')
 *         if __nvmlSystemEventSetWait == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1939
 * 
 *         global __nvmlDeviceModifyDrainState
 *         __nvmlDeviceModifyDrainState = dlsym(RTLD_DEFAULT, 'nvmlDeviceModifyDrainState')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceModifyDrainState == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceModifyDrainState = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceModifyDrainState);

                /* "cuda/bindings/_internal/_nvml.pyx":1940
 *         global __nvmlDeviceModifyDrainState
 *         __nvmlDeviceModifyDrainState = dlsym(RTLD_DEFAULT, 'nvmlDeviceModifyDrainState')
 *         if __nvmlDeviceModifyDrainState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceModifyDrainState == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1941
 *         __nvmlDeviceModifyDrainState = dlsym(RTLD_DEFAULT, 'nvmlDeviceModifyDrainState')
 *         if __nvmlDeviceModifyDrainState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceModifyDrainState = dlsym(handle, 'nvmlDeviceModifyDrainState')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1942
 *         if __nvmlDeviceModifyDrainState == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceModifyDrainState = dlsym(handle, 'nvmlDeviceModifyDrainState')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1942, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1941
 *         __nvmlDeviceModifyDrainState = dlsym(RTLD_DEFAULT, 'nvmlDeviceModifyDrainState')
 *         if __nvmlDeviceModifyDrainState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceModifyDrainState = dlsym(handle, 'nvmlDeviceModifyDrainState')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1943
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceModifyDrainState = dlsym(handle, 'nvmlDeviceModifyDrainState')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceQueryDrainState
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceModifyDrainState = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceModifyDrainState);

                  /* "cuda/bindings/_internal/_nvml.pyx":1940
 *         global __nvmlDeviceModifyDrainState
 *         __nvmlDeviceModifyDrainState = dlsym(RTLD_DEFAULT, 'nvmlDeviceModifyDrainState')
 *         if __nvmlDeviceModifyDrainState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1946
 * 
 *         global __nvmlDeviceQueryDrainState
 *         __nvmlDeviceQueryDrainState = dlsym(RTLD_DEFAULT, 'nvmlDeviceQueryDrainState')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceQueryDrainState == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceQueryDrainState = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceQueryDrainState);

                /* "cuda/bindings/_internal/_nvml.pyx":1947
 *         global __nvmlDeviceQueryDrainState
 *         __nvmlDeviceQueryDrainState = dlsym(RTLD_DEFAULT, 'nvmlDeviceQueryDrainState')
 *         if __nvmlDeviceQueryDrainState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceQueryDrainState == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1948
 *         __nvmlDeviceQueryDrainState = dlsym(RTLD_DEFAULT, 'nvmlDeviceQueryDrainState')
 *         if __nvmlDeviceQueryDrainState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceQueryDrainState = dlsym(handle, 'nvmlDeviceQueryDrainState')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1949
 *         if __nvmlDeviceQueryDrainState == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceQueryDrainState = dlsym(handle, 'nvmlDeviceQueryDrainState')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1949, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1948
 *         __nvmlDeviceQueryDrainState = dlsym(RTLD_DEFAULT, 'nvmlDeviceQueryDrainState')
 *         if __nvmlDeviceQueryDrainState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceQueryDrainState = dlsym(handle, 'nvmlDeviceQueryDrainState')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1950
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceQueryDrainState = dlsym(handle, 'nvmlDeviceQueryDrainState')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceRemoveGpu_v2
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceQueryDrainState = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceQueryDrainState);

                  /* "cuda/bindings/_internal/_nvml.pyx":1947
 *         global __nvmlDeviceQueryDrainState
 *         __nvmlDeviceQueryDrainState = dlsym(RTLD_DEFAULT, 'nvmlDeviceQueryDrainState')
 *         if __nvmlDeviceQueryDrainState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1953
 * 
 *         global __nvmlDeviceRemoveGpu_v2
 *         __nvmlDeviceRemoveGpu_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceRemoveGpu_v2')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceRemoveGpu_v2 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceRemoveGpu_v2 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceRemoveGpu_v2);

                /* "cuda/bindings/_internal/_nvml.pyx":1954
 *         global __nvmlDeviceRemoveGpu_v2
 *         __nvmlDeviceRemoveGpu_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceRemoveGpu_v2')
 *         if __nvmlDeviceRemoveGpu_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceRemoveGpu_v2 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1955
 *         __nvmlDeviceRemoveGpu_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceRemoveGpu_v2')
 *         if __nvmlDeviceRemoveGpu_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceRemoveGpu_v2 = dlsym(handle, 'nvmlDeviceRemoveGpu_v2')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1956
 *         if __nvmlDeviceRemoveGpu_v2 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceRemoveGpu_v2 = dlsym(handle, 'nvmlDeviceRemoveGpu_v2')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1956, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1955
 *         __nvmlDeviceRemoveGpu_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceRemoveGpu_v2')
 *         if __nvmlDeviceRemoveGpu_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceRemoveGpu_v2 = dlsym(handle, 'nvmlDeviceRemoveGpu_v2')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1957
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceRemoveGpu_v2 = dlsym(handle, 'nvmlDeviceRemoveGpu_v2')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceDiscoverGpus
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceRemoveGpu_v2 = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceRemoveGpu_v2);

                  /* "cuda/bindings/_internal/_nvml.pyx":1954
 *         global __nvmlDeviceRemoveGpu_v2
 *         __nvmlDeviceRemoveGpu_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceRemoveGpu_v2')
 *         if __nvmlDeviceRemoveGpu_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1960
 * 
 *         global __nvmlDeviceDiscoverGpus
 *         __nvmlDeviceDiscoverGpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceDiscoverGpus')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceDiscoverGpus == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceDiscoverGpus = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceDiscoverGpus);

                /* "cuda/bindings/_internal/_nvml.pyx":1961
 *         global __nvmlDeviceDiscoverGpus
 *         __nvmlDeviceDiscoverGpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceDiscoverGpus')
 *         if __nvmlDeviceDiscoverGpus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceDiscoverGpus == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1962
 *         __nvmlDeviceDiscoverGpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceDiscoverGpus')
 *         if __nvmlDeviceDiscoverGpus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceDiscoverGpus = dlsym(handle, 'nvmlDeviceDiscoverGpus')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1963
 *         if __nvmlDeviceDiscoverGpus == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceDiscoverGpus = dlsym(handle, 'nvmlDeviceDiscoverGpus')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1963, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1962
 *         __nvmlDeviceDiscoverGpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceDiscoverGpus')
 *         if __nvmlDeviceDiscoverGpus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceDiscoverGpus = dlsym(handle, 'nvmlDeviceDiscoverGpus')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1964
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceDiscoverGpus = dlsym(handle, 'nvmlDeviceDiscoverGpus')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetFieldValues
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceDiscoverGpus = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceDiscoverGpus);

                  /* "cuda/bindings/_internal/_nvml.pyx":1961
 *         global __nvmlDeviceDiscoverGpus
 *         __nvmlDeviceDiscoverGpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceDiscoverGpus')
 *         if __nvmlDeviceDiscoverGpus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1967
 * 
 *         global __nvmlDeviceGetFieldValues
 *         __nvmlDeviceGetFieldValues = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFieldValues')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetFieldValues == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFieldValues = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetFieldValues);

                /* "cuda/bindings/_internal/_nvml.pyx":1968
 *         global __nvmlDeviceGetFieldValues
 *         __nvmlDeviceGetFieldValues = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFieldValues')
 *         if __nvmlDeviceGetFieldValues == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFieldValues == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1969
 *         __nvmlDeviceGetFieldValues = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFieldValues')
 *         if __nvmlDeviceGetFieldValues == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetFieldValues = dlsym(handle, 'nvmlDeviceGetFieldValues')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1970
 *         if __nvmlDeviceGetFieldValues == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetFieldValues = dlsym(handle, 'nvmlDeviceGetFieldValues')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1970, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1969
 *         __nvmlDeviceGetFieldValues = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFieldValues')
 *         if __nvmlDeviceGetFieldValues == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetFieldValues = dlsym(handle, 'nvmlDeviceGetFieldValues')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1971
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetFieldValues = dlsym(handle, 'nvmlDeviceGetFieldValues')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceClearFieldValues
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFieldValues = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetFieldValues);

                  /* "cuda/bindings/_internal/_nvml.pyx":1968
 *         global __nvmlDeviceGetFieldValues
 *         __nvmlDeviceGetFieldValues = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetFieldValues')
 *         if __nvmlDeviceGetFieldValues == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1974
 * 
 *         global __nvmlDeviceClearFieldValues
 *         __nvmlDeviceClearFieldValues = dlsym(RTLD_DEFAULT, 'nvmlDeviceClearFieldValues')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceClearFieldValues == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearFieldValues = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceClearFieldValues);

                /* "cuda/bindings/_internal/_nvml.pyx":1975
 *         global __nvmlDeviceClearFieldValues
 *         __nvmlDeviceClearFieldValues = dlsym(RTLD_DEFAULT, 'nvmlDeviceClearFieldValues')
 *         if __nvmlDeviceClearFieldValues == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearFieldValues == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1976
 *         __nvmlDeviceClearFieldValues = dlsym(RTLD_DEFAULT, 'nvmlDeviceClearFieldValues')
 *         if __nvmlDeviceClearFieldValues == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceClearFieldValues = dlsym(handle, 'nvmlDeviceClearFieldValues')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1977
 *         if __nvmlDeviceClearFieldValues == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceClearFieldValues = dlsym(handle, 'nvmlDeviceClearFieldValues')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1977, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1976
 *         __nvmlDeviceClearFieldValues = dlsym(RTLD_DEFAULT, 'nvmlDeviceClearFieldValues')
 *         if __nvmlDeviceClearFieldValues == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceClearFieldValues = dlsym(handle, 'nvmlDeviceClearFieldValues')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1978
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceClearFieldValues = dlsym(handle, 'nvmlDeviceClearFieldValues')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetVirtualizationMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearFieldValues = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceClearFieldValues);

                  /* "cuda/bindings/_internal/_nvml.pyx":1975
 *         global __nvmlDeviceClearFieldValues
 *         __nvmlDeviceClearFieldValues = dlsym(RTLD_DEFAULT, 'nvmlDeviceClearFieldValues')
 *         if __nvmlDeviceClearFieldValues == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1981
 * 
 *         global __nvmlDeviceGetVirtualizationMode
 *         __nvmlDeviceGetVirtualizationMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVirtualizationMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetVirtualizationMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVirtualizationMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetVirtualizationMode);

                /* "cuda/bindings/_internal/_nvml.pyx":1982
 *         global __nvmlDeviceGetVirtualizationMode
 *         __nvmlDeviceGetVirtualizationMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVirtualizationMode')
 *         if __nvmlDeviceGetVirtualizationMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVirtualizationMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1983
 *         __nvmlDeviceGetVirtualizationMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVirtualizationMode')
 *         if __nvmlDeviceGetVirtualizationMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVirtualizationMode = dlsym(handle, 'nvmlDeviceGetVirtualizationMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1984
 *         if __nvmlDeviceGetVirtualizationMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetVirtualizationMode = dlsym(handle, 'nvmlDeviceGetVirtualizationMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1984, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1983
 *         __nvmlDeviceGetVirtualizationMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVirtualizationMode')
 *         if __nvmlDeviceGetVirtualizationMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVirtualizationMode = dlsym(handle, 'nvmlDeviceGetVirtualizationMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1985
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetVirtualizationMode = dlsym(handle, 'nvmlDeviceGetVirtualizationMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetHostVgpuMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVirtualizationMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetVirtualizationMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":1982
 *         global __nvmlDeviceGetVirtualizationMode
 *         __nvmlDeviceGetVirtualizationMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVirtualizationMode')
 *         if __nvmlDeviceGetVirtualizationMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1988
 * 
 *         global __nvmlDeviceGetHostVgpuMode
 *         __nvmlDeviceGetHostVgpuMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHostVgpuMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetHostVgpuMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHostVgpuMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetHostVgpuMode);

                /* "cuda/bindings/_internal/_nvml.pyx":1989
 *         global __nvmlDeviceGetHostVgpuMode
 *         __nvmlDeviceGetHostVgpuMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHostVgpuMode')
 *         if __nvmlDeviceGetHostVgpuMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHostVgpuMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1990
 *         __nvmlDeviceGetHostVgpuMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHostVgpuMode')
 *         if __nvmlDeviceGetHostVgpuMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetHostVgpuMode = dlsym(handle, 'nvmlDeviceGetHostVgpuMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1991
 *         if __nvmlDeviceGetHostVgpuMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetHostVgpuMode = dlsym(handle, 'nvmlDeviceGetHostVgpuMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1991, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1990
 *         __nvmlDeviceGetHostVgpuMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHostVgpuMode')
 *         if __nvmlDeviceGetHostVgpuMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetHostVgpuMode = dlsym(handle, 'nvmlDeviceGetHostVgpuMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1992
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetHostVgpuMode = dlsym(handle, 'nvmlDeviceGetHostVgpuMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetVirtualizationMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHostVgpuMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetHostVgpuMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":1989
 *         global __nvmlDeviceGetHostVgpuMode
 *         __nvmlDeviceGetHostVgpuMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHostVgpuMode')
 *         if __nvmlDeviceGetHostVgpuMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":1995
 * 
 *         global __nvmlDeviceSetVirtualizationMode
 *         __nvmlDeviceSetVirtualizationMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVirtualizationMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetVirtualizationMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVirtualizationMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetVirtualizationMode);

                /* "cuda/bindings/_internal/_nvml.pyx":1996
 *         global __nvmlDeviceSetVirtualizationMode
 *         __nvmlDeviceSetVirtualizationMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVirtualizationMode')
 *         if __nvmlDeviceSetVirtualizationMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVirtualizationMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":1997
 *         __nvmlDeviceSetVirtualizationMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVirtualizationMode')
 *         if __nvmlDeviceSetVirtualizationMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetVirtualizationMode = dlsym(handle, 'nvmlDeviceSetVirtualizationMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":1998
 *         if __nvmlDeviceSetVirtualizationMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetVirtualizationMode = dlsym(handle, 'nvmlDeviceSetVirtualizationMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1998, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":1997
 *         __nvmlDeviceSetVirtualizationMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVirtualizationMode')
 *         if __nvmlDeviceSetVirtualizationMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetVirtualizationMode = dlsym(handle, 'nvmlDeviceSetVirtualizationMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":1999
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetVirtualizationMode = dlsym(handle, 'nvmlDeviceSetVirtualizationMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetVgpuHeterogeneousMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVirtualizationMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetVirtualizationMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":1996
 *         global __nvmlDeviceSetVirtualizationMode
 *         __nvmlDeviceSetVirtualizationMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVirtualizationMode')
 *         if __nvmlDeviceSetVirtualizationMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2002
 * 
 *         global __nvmlDeviceGetVgpuHeterogeneousMode
 *         __nvmlDeviceGetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuHeterogeneousMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetVgpuHeterogeneousMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetVgpuHeterogeneousMo);

                /* "cuda/bindings/_internal/_nvml.pyx":2003
 *         global __nvmlDeviceGetVgpuHeterogeneousMode
 *         __nvmlDeviceGetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuHeterogeneousMode')
 *         if __nvmlDeviceGetVgpuHeterogeneousMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuHeterogeneousMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2004
 *         __nvmlDeviceGetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuHeterogeneousMode')
 *         if __nvmlDeviceGetVgpuHeterogeneousMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuHeterogeneousMode = dlsym(handle, 'nvmlDeviceGetVgpuHeterogeneousMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2005
 *         if __nvmlDeviceGetVgpuHeterogeneousMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetVgpuHeterogeneousMode = dlsym(handle, 'nvmlDeviceGetVgpuHeterogeneousMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2005, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2004
 *         __nvmlDeviceGetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuHeterogeneousMode')
 *         if __nvmlDeviceGetVgpuHeterogeneousMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuHeterogeneousMode = dlsym(handle, 'nvmlDeviceGetVgpuHeterogeneousMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2006
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuHeterogeneousMode = dlsym(handle, 'nvmlDeviceGetVgpuHeterogeneousMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetVgpuHeterogeneousMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuHeterogeneousMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetVgpuHeterogeneousMo);

                  /* "cuda/bindings/_internal/_nvml.pyx":2003
 *         global __nvmlDeviceGetVgpuHeterogeneousMode
 *         __nvmlDeviceGetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuHeterogeneousMode')
 *         if __nvmlDeviceGetVgpuHeterogeneousMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2009
 * 
 *         global __nvmlDeviceSetVgpuHeterogeneousMode
 *         __nvmlDeviceSetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVgpuHeterogeneousMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetVgpuHeterogeneousMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetVgpuHeterogeneousMo);

                /* "cuda/bindings/_internal/_nvml.pyx":2010
 *         global __nvmlDeviceSetVgpuHeterogeneousMode
 *         __nvmlDeviceSetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVgpuHeterogeneousMode')
 *         if __nvmlDeviceSetVgpuHeterogeneousMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVgpuHeterogeneousMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2011
 *         __nvmlDeviceSetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVgpuHeterogeneousMode')
 *         if __nvmlDeviceSetVgpuHeterogeneousMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetVgpuHeterogeneousMode = dlsym(handle, 'nvmlDeviceSetVgpuHeterogeneousMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2012
 *         if __nvmlDeviceSetVgpuHeterogeneousMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetVgpuHeterogeneousMode = dlsym(handle, 'nvmlDeviceSetVgpuHeterogeneousMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2012, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2011
 *         __nvmlDeviceSetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVgpuHeterogeneousMode')
 *         if __nvmlDeviceSetVgpuHeterogeneousMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetVgpuHeterogeneousMode = dlsym(handle, 'nvmlDeviceSetVgpuHeterogeneousMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2013
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetVgpuHeterogeneousMode = dlsym(handle, 'nvmlDeviceSetVgpuHeterogeneousMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceGetPlacementId
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVgpuHeterogeneousMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetVgpuHeterogeneousMo);

                  /* "cuda/bindings/_internal/_nvml.pyx":2010
 *         global __nvmlDeviceSetVgpuHeterogeneousMode
 *         __nvmlDeviceSetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVgpuHeterogeneousMode')
 *         if __nvmlDeviceSetVgpuHeterogeneousMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2016
 * 
 *         global __nvmlVgpuInstanceGetPlacementId
 *         __nvmlVgpuInstanceGetPlacementId = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetPlacementId')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceGetPlacementId == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetPlacementId = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceGetPlacementId);

                /* "cuda/bindings/_internal/_nvml.pyx":2017
 *         global __nvmlVgpuInstanceGetPlacementId
 *         __nvmlVgpuInstanceGetPlacementId = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetPlacementId')
 *         if __nvmlVgpuInstanceGetPlacementId == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetPlacementId == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2018
 *         __nvmlVgpuInstanceGetPlacementId = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetPlacementId')
 *         if __nvmlVgpuInstanceGetPlacementId == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetPlacementId = dlsym(handle, 'nvmlVgpuInstanceGetPlacementId')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2019
 *         if __nvmlVgpuInstanceGetPlacementId == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceGetPlacementId = dlsym(handle, 'nvmlVgpuInstanceGetPlacementId')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2019, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2018
 *         __nvmlVgpuInstanceGetPlacementId = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetPlacementId')
 *         if __nvmlVgpuInstanceGetPlacementId == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetPlacementId = dlsym(handle, 'nvmlVgpuInstanceGetPlacementId')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2020
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetPlacementId = dlsym(handle, 'nvmlVgpuInstanceGetPlacementId')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetVgpuTypeSupportedPlacements
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetPlacementId = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceGetPlacementId);

                  /* "cuda/bindings/_internal/_nvml.pyx":2017
 *         global __nvmlVgpuInstanceGetPlacementId
 *         __nvmlVgpuInstanceGetPlacementId = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetPlacementId')
 *         if __nvmlVgpuInstanceGetPlacementId == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2023
 * 
 *         global __nvmlDeviceGetVgpuTypeSupportedPlacements
 *         __nvmlDeviceGetVgpuTypeSupportedPlacements = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuTypeSupportedPlacements')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetVgpuTypeSupportedPlacements == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuTypeSupportedPlacements = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetVgpuTypeSupportedPl);

                /* "cuda/bindings/_internal/_nvml.pyx":2024
 *         global __nvmlDeviceGetVgpuTypeSupportedPlacements
 *         __nvmlDeviceGetVgpuTypeSupportedPlacements = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuTypeSupportedPlacements')
 *         if __nvmlDeviceGetVgpuTypeSupportedPlacements == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuTypeSupportedPlacements == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2025
 *         __nvmlDeviceGetVgpuTypeSupportedPlacements = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuTypeSupportedPlacements')
 *         if __nvmlDeviceGetVgpuTypeSupportedPlacements == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuTypeSupportedPlacements = dlsym(handle, 'nvmlDeviceGetVgpuTypeSupportedPlacements')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2026
 *         if __nvmlDeviceGetVgpuTypeSupportedPlacements == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetVgpuTypeSupportedPlacements = dlsym(handle, 'nvmlDeviceGetVgpuTypeSupportedPlacements')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2026, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2025
 *         __nvmlDeviceGetVgpuTypeSupportedPlacements = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuTypeSupportedPlacements')
 *         if __nvmlDeviceGetVgpuTypeSupportedPlacements == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuTypeSupportedPlacements = dlsym(handle, 'nvmlDeviceGetVgpuTypeSupportedPlacements')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2027
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuTypeSupportedPlacements = dlsym(handle, 'nvmlDeviceGetVgpuTypeSupportedPlacements')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetVgpuTypeCreatablePlacements
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuTypeSupportedPlacements = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetVgpuTypeSupportedPl);

                  /* "cuda/bindings/_internal/_nvml.pyx":2024
 *         global __nvmlDeviceGetVgpuTypeSupportedPlacements
 *         __nvmlDeviceGetVgpuTypeSupportedPlacements = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuTypeSupportedPlacements')
 *         if __nvmlDeviceGetVgpuTypeSupportedPlacements == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2030
 * 
 *         global __nvmlDeviceGetVgpuTypeCreatablePlacements
 *         __nvmlDeviceGetVgpuTypeCreatablePlacements = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuTypeCreatablePlacements')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetVgpuTypeCreatablePlacements == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuTypeCreatablePlacements = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetVgpuTypeCreatablePl);

                /* "cuda/bindings/_internal/_nvml.pyx":2031
 *         global __nvmlDeviceGetVgpuTypeCreatablePlacements
 *         __nvmlDeviceGetVgpuTypeCreatablePlacements = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuTypeCreatablePlacements')
 *         if __nvmlDeviceGetVgpuTypeCreatablePlacements == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuTypeCreatablePlacements == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2032
 *         __nvmlDeviceGetVgpuTypeCreatablePlacements = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuTypeCreatablePlacements')
 *         if __nvmlDeviceGetVgpuTypeCreatablePlacements == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuTypeCreatablePlacements = dlsym(handle, 'nvmlDeviceGetVgpuTypeCreatablePlacements')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2033
 *         if __nvmlDeviceGetVgpuTypeCreatablePlacements == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetVgpuTypeCreatablePlacements = dlsym(handle, 'nvmlDeviceGetVgpuTypeCreatablePlacements')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2033, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2032
 *         __nvmlDeviceGetVgpuTypeCreatablePlacements = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuTypeCreatablePlacements')
 *         if __nvmlDeviceGetVgpuTypeCreatablePlacements == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuTypeCreatablePlacements = dlsym(handle, 'nvmlDeviceGetVgpuTypeCreatablePlacements')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2034
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuTypeCreatablePlacements = dlsym(handle, 'nvmlDeviceGetVgpuTypeCreatablePlacements')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuTypeGetGspHeapSize
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuTypeCreatablePlacements = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetVgpuTypeCreatablePl);

                  /* "cuda/bindings/_internal/_nvml.pyx":2031
 *         global __nvmlDeviceGetVgpuTypeCreatablePlacements
 *         __nvmlDeviceGetVgpuTypeCreatablePlacements = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuTypeCreatablePlacements')
 *         if __nvmlDeviceGetVgpuTypeCreatablePlacements == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2037
 * 
 *         global __nvmlVgpuTypeGetGspHeapSize
 *         __nvmlVgpuTypeGetGspHeapSize = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetGspHeapSize')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuTypeGetGspHeapSize == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetGspHeapSize = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuTypeGetGspHeapSize);

                /* "cuda/bindings/_internal/_nvml.pyx":2038
 *         global __nvmlVgpuTypeGetGspHeapSize
 *         __nvmlVgpuTypeGetGspHeapSize = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetGspHeapSize')
 *         if __nvmlVgpuTypeGetGspHeapSize == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetGspHeapSize == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2039
 *         __nvmlVgpuTypeGetGspHeapSize = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetGspHeapSize')
 *         if __nvmlVgpuTypeGetGspHeapSize == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetGspHeapSize = dlsym(handle, 'nvmlVgpuTypeGetGspHeapSize')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2040
 *         if __nvmlVgpuTypeGetGspHeapSize == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuTypeGetGspHeapSize = dlsym(handle, 'nvmlVgpuTypeGetGspHeapSize')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2040, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2039
 *         __nvmlVgpuTypeGetGspHeapSize = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetGspHeapSize')
 *         if __nvmlVgpuTypeGetGspHeapSize == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetGspHeapSize = dlsym(handle, 'nvmlVgpuTypeGetGspHeapSize')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2041
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetGspHeapSize = dlsym(handle, 'nvmlVgpuTypeGetGspHeapSize')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuTypeGetFbReservation
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetGspHeapSize = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuTypeGetGspHeapSize);

                  /* "cuda/bindings/_internal/_nvml.pyx":2038
 *         global __nvmlVgpuTypeGetGspHeapSize
 *         __nvmlVgpuTypeGetGspHeapSize = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetGspHeapSize')
 *         if __nvmlVgpuTypeGetGspHeapSize == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2044
 * 
 *         global __nvmlVgpuTypeGetFbReservation
 *         __nvmlVgpuTypeGetFbReservation = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetFbReservation')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuTypeGetFbReservation == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetFbReservation = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuTypeGetFbReservation);

                /* "cuda/bindings/_internal/_nvml.pyx":2045
 *         global __nvmlVgpuTypeGetFbReservation
 *         __nvmlVgpuTypeGetFbReservation = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetFbReservation')
 *         if __nvmlVgpuTypeGetFbReservation == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetFbReservation == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2046
 *         __nvmlVgpuTypeGetFbReservation = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetFbReservation')
 *         if __nvmlVgpuTypeGetFbReservation == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetFbReservation = dlsym(handle, 'nvmlVgpuTypeGetFbReservation')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2047
 *         if __nvmlVgpuTypeGetFbReservation == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuTypeGetFbReservation = dlsym(handle, 'nvmlVgpuTypeGetFbReservation')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2047, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2046
 *         __nvmlVgpuTypeGetFbReservation = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetFbReservation')
 *         if __nvmlVgpuTypeGetFbReservation == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetFbReservation = dlsym(handle, 'nvmlVgpuTypeGetFbReservation')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2048
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetFbReservation = dlsym(handle, 'nvmlVgpuTypeGetFbReservation')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceGetRuntimeStateSize
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetFbReservation = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuTypeGetFbReservation);

                  /* "cuda/bindings/_internal/_nvml.pyx":2045
 *         global __nvmlVgpuTypeGetFbReservation
 *         __nvmlVgpuTypeGetFbReservation = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetFbReservation')
 *         if __nvmlVgpuTypeGetFbReservation == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2051
 * 
 *         global __nvmlVgpuInstanceGetRuntimeStateSize
 *         __nvmlVgpuInstanceGetRuntimeStateSize = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetRuntimeStateSize')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceGetRuntimeStateSize == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetRuntimeStateSize = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceGetRuntimeStateS);

                /* "cuda/bindings/_internal/_nvml.pyx":2052
 *         global __nvmlVgpuInstanceGetRuntimeStateSize
 *         __nvmlVgpuInstanceGetRuntimeStateSize = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetRuntimeStateSize')
 *         if __nvmlVgpuInstanceGetRuntimeStateSize == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetRuntimeStateSize == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2053
 *         __nvmlVgpuInstanceGetRuntimeStateSize = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetRuntimeStateSize')
 *         if __nvmlVgpuInstanceGetRuntimeStateSize == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetRuntimeStateSize = dlsym(handle, 'nvmlVgpuInstanceGetRuntimeStateSize')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2054
 *         if __nvmlVgpuInstanceGetRuntimeStateSize == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceGetRuntimeStateSize = dlsym(handle, 'nvmlVgpuInstanceGetRuntimeStateSize')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2054, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2053
 *         __nvmlVgpuInstanceGetRuntimeStateSize = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetRuntimeStateSize')
 *         if __nvmlVgpuInstanceGetRuntimeStateSize == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetRuntimeStateSize = dlsym(handle, 'nvmlVgpuInstanceGetRuntimeStateSize')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2055
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetRuntimeStateSize = dlsym(handle, 'nvmlVgpuInstanceGetRuntimeStateSize')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetVgpuCapabilities
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetRuntimeStateSize = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceGetRuntimeStateS);

                  /* "cuda/bindings/_internal/_nvml.pyx":2052
 *         global __nvmlVgpuInstanceGetRuntimeStateSize
 *         __nvmlVgpuInstanceGetRuntimeStateSize = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetRuntimeStateSize')
 *         if __nvmlVgpuInstanceGetRuntimeStateSize == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2058
 * 
 *         global __nvmlDeviceSetVgpuCapabilities
 *         __nvmlDeviceSetVgpuCapabilities = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVgpuCapabilities')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetVgpuCapabilities == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVgpuCapabilities = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetVgpuCapabilities);

                /* "cuda/bindings/_internal/_nvml.pyx":2059
 *         global __nvmlDeviceSetVgpuCapabilities
 *         __nvmlDeviceSetVgpuCapabilities = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVgpuCapabilities')
 *         if __nvmlDeviceSetVgpuCapabilities == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVgpuCapabilities == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2060
 *         __nvmlDeviceSetVgpuCapabilities = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVgpuCapabilities')
 *         if __nvmlDeviceSetVgpuCapabilities == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetVgpuCapabilities = dlsym(handle, 'nvmlDeviceSetVgpuCapabilities')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2061
 *         if __nvmlDeviceSetVgpuCapabilities == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetVgpuCapabilities = dlsym(handle, 'nvmlDeviceSetVgpuCapabilities')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2061, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2060
 *         __nvmlDeviceSetVgpuCapabilities = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVgpuCapabilities')
 *         if __nvmlDeviceSetVgpuCapabilities == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetVgpuCapabilities = dlsym(handle, 'nvmlDeviceSetVgpuCapabilities')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2062
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetVgpuCapabilities = dlsym(handle, 'nvmlDeviceSetVgpuCapabilities')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetGridLicensableFeatures_v4
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVgpuCapabilities = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetVgpuCapabilities);

                  /* "cuda/bindings/_internal/_nvml.pyx":2059
 *         global __nvmlDeviceSetVgpuCapabilities
 *         __nvmlDeviceSetVgpuCapabilities = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVgpuCapabilities')
 *         if __nvmlDeviceSetVgpuCapabilities == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2065
 * 
 *         global __nvmlDeviceGetGridLicensableFeatures_v4
 *         __nvmlDeviceGetGridLicensableFeatures_v4 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGridLicensableFeatures_v4')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetGridLicensableFeatures_v4 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGridLicensableFeatures_v4 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetGridLicensableFeatu);

                /* "cuda/bindings/_internal/_nvml.pyx":2066
 *         global __nvmlDeviceGetGridLicensableFeatures_v4
 *         __nvmlDeviceGetGridLicensableFeatures_v4 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGridLicensableFeatures_v4')
 *         if __nvmlDeviceGetGridLicensableFeatures_v4 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGridLicensableFeatures_v4 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2067
 *         __nvmlDeviceGetGridLicensableFeatures_v4 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGridLicensableFeatures_v4')
 *         if __nvmlDeviceGetGridLicensableFeatures_v4 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGridLicensableFeatures_v4 = dlsym(handle, 'nvmlDeviceGetGridLicensableFeatures_v4')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2068
 *         if __nvmlDeviceGetGridLicensableFeatures_v4 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetGridLicensableFeatures_v4 = dlsym(handle, 'nvmlDeviceGetGridLicensableFeatures_v4')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2068, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2067
 *         __nvmlDeviceGetGridLicensableFeatures_v4 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGridLicensableFeatures_v4')
 *         if __nvmlDeviceGetGridLicensableFeatures_v4 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGridLicensableFeatures_v4 = dlsym(handle, 'nvmlDeviceGetGridLicensableFeatures_v4')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2069
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetGridLicensableFeatures_v4 = dlsym(handle, 'nvmlDeviceGetGridLicensableFeatures_v4')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGetVgpuDriverCapabilities
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGridLicensableFeatures_v4 = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetGridLicensableFeatu);

                  /* "cuda/bindings/_internal/_nvml.pyx":2066
 *         global __nvmlDeviceGetGridLicensableFeatures_v4
 *         __nvmlDeviceGetGridLicensableFeatures_v4 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGridLicensableFeatures_v4')
 *         if __nvmlDeviceGetGridLicensableFeatures_v4 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2072
 * 
 *         global __nvmlGetVgpuDriverCapabilities
 *         __nvmlGetVgpuDriverCapabilities = dlsym(RTLD_DEFAULT, 'nvmlGetVgpuDriverCapabilities')             # <<<<<<<<<<<<<<
 *         if __nvmlGetVgpuDriverCapabilities == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetVgpuDriverCapabilities = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGetVgpuDriverCapabilities);

                /* "cuda/bindings/_internal/_nvml.pyx":2073
 *         global __nvmlGetVgpuDriverCapabilities
 *         __nvmlGetVgpuDriverCapabilities = dlsym(RTLD_DEFAULT, 'nvmlGetVgpuDriverCapabilities')
 *         if __nvmlGetVgpuDriverCapabilities == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetVgpuDriverCapabilities == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2074
 *         __nvmlGetVgpuDriverCapabilities = dlsym(RTLD_DEFAULT, 'nvmlGetVgpuDriverCapabilities')
 *         if __nvmlGetVgpuDriverCapabilities == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGetVgpuDriverCapabilities = dlsym(handle, 'nvmlGetVgpuDriverCapabilities')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2075
 *         if __nvmlGetVgpuDriverCapabilities == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGetVgpuDriverCapabilities = dlsym(handle, 'nvmlGetVgpuDriverCapabilities')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2075, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2074
 *         __nvmlGetVgpuDriverCapabilities = dlsym(RTLD_DEFAULT, 'nvmlGetVgpuDriverCapabilities')
 *         if __nvmlGetVgpuDriverCapabilities == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGetVgpuDriverCapabilities = dlsym(handle, 'nvmlGetVgpuDriverCapabilities')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2076
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGetVgpuDriverCapabilities = dlsym(handle, 'nvmlGetVgpuDriverCapabilities')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetVgpuCapabilities
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetVgpuDriverCapabilities = dlsym(__pyx_v_handle, __pyx_k_nvmlGetVgpuDriverCapabilities);

                  /* "cuda/bindings/_internal/_nvml.pyx":2073
 *         global __nvmlGetVgpuDriverCapabilities
 *         __nvmlGetVgpuDriverCapabilities = dlsym(RTLD_DEFAULT, 'nvmlGetVgpuDriverCapabilities')
 *         if __nvmlGetVgpuDriverCapabilities == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2079
 * 
 *         global __nvmlDeviceGetVgpuCapabilities
 *         __nvmlDeviceGetVgpuCapabilities = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuCapabilities')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetVgpuCapabilities == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuCapabilities = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetVgpuCapabilities);

                /* "cuda/bindings/_internal/_nvml.pyx":2080
 *         global __nvmlDeviceGetVgpuCapabilities
 *         __nvmlDeviceGetVgpuCapabilities = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuCapabilities')
 *         if __nvmlDeviceGetVgpuCapabilities == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuCapabilities == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2081
 *         __nvmlDeviceGetVgpuCapabilities = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuCapabilities')
 *         if __nvmlDeviceGetVgpuCapabilities == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuCapabilities = dlsym(handle, 'nvmlDeviceGetVgpuCapabilities')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2082
 *         if __nvmlDeviceGetVgpuCapabilities == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetVgpuCapabilities = dlsym(handle, 'nvmlDeviceGetVgpuCapabilities')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2082, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2081
 *         __nvmlDeviceGetVgpuCapabilities = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuCapabilities')
 *         if __nvmlDeviceGetVgpuCapabilities == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuCapabilities = dlsym(handle, 'nvmlDeviceGetVgpuCapabilities')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2083
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuCapabilities = dlsym(handle, 'nvmlDeviceGetVgpuCapabilities')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetSupportedVgpus
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuCapabilities = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetVgpuCapabilities);

                  /* "cuda/bindings/_internal/_nvml.pyx":2080
 *         global __nvmlDeviceGetVgpuCapabilities
 *         __nvmlDeviceGetVgpuCapabilities = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuCapabilities')
 *         if __nvmlDeviceGetVgpuCapabilities == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2086
 * 
 *         global __nvmlDeviceGetSupportedVgpus
 *         __nvmlDeviceGetSupportedVgpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedVgpus')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetSupportedVgpus == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedVgpus = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetSupportedVgpus);

                /* "cuda/bindings/_internal/_nvml.pyx":2087
 *         global __nvmlDeviceGetSupportedVgpus
 *         __nvmlDeviceGetSupportedVgpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedVgpus')
 *         if __nvmlDeviceGetSupportedVgpus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedVgpus == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2088
 *         __nvmlDeviceGetSupportedVgpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedVgpus')
 *         if __nvmlDeviceGetSupportedVgpus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetSupportedVgpus = dlsym(handle, 'nvmlDeviceGetSupportedVgpus')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2089
 *         if __nvmlDeviceGetSupportedVgpus == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetSupportedVgpus = dlsym(handle, 'nvmlDeviceGetSupportedVgpus')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2089, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2088
 *         __nvmlDeviceGetSupportedVgpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedVgpus')
 *         if __nvmlDeviceGetSupportedVgpus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetSupportedVgpus = dlsym(handle, 'nvmlDeviceGetSupportedVgpus')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2090
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetSupportedVgpus = dlsym(handle, 'nvmlDeviceGetSupportedVgpus')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetCreatableVgpus
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedVgpus = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetSupportedVgpus);

                  /* "cuda/bindings/_internal/_nvml.pyx":2087
 *         global __nvmlDeviceGetSupportedVgpus
 *         __nvmlDeviceGetSupportedVgpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSupportedVgpus')
 *         if __nvmlDeviceGetSupportedVgpus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2093
 * 
 *         global __nvmlDeviceGetCreatableVgpus
 *         __nvmlDeviceGetCreatableVgpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCreatableVgpus')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetCreatableVgpus == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCreatableVgpus = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetCreatableVgpus);

                /* "cuda/bindings/_internal/_nvml.pyx":2094
 *         global __nvmlDeviceGetCreatableVgpus
 *         __nvmlDeviceGetCreatableVgpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCreatableVgpus')
 *         if __nvmlDeviceGetCreatableVgpus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCreatableVgpus == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2095
 *         __nvmlDeviceGetCreatableVgpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCreatableVgpus')
 *         if __nvmlDeviceGetCreatableVgpus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetCreatableVgpus = dlsym(handle, 'nvmlDeviceGetCreatableVgpus')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2096
 *         if __nvmlDeviceGetCreatableVgpus == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetCreatableVgpus = dlsym(handle, 'nvmlDeviceGetCreatableVgpus')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2096, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2095
 *         __nvmlDeviceGetCreatableVgpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCreatableVgpus')
 *         if __nvmlDeviceGetCreatableVgpus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetCreatableVgpus = dlsym(handle, 'nvmlDeviceGetCreatableVgpus')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2097
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetCreatableVgpus = dlsym(handle, 'nvmlDeviceGetCreatableVgpus')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuTypeGetClass
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCreatableVgpus = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetCreatableVgpus);

                  /* "cuda/bindings/_internal/_nvml.pyx":2094
 *         global __nvmlDeviceGetCreatableVgpus
 *         __nvmlDeviceGetCreatableVgpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCreatableVgpus')
 *         if __nvmlDeviceGetCreatableVgpus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2100
 * 
 *         global __nvmlVgpuTypeGetClass
 *         __nvmlVgpuTypeGetClass = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetClass')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuTypeGetClass == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetClass = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuTypeGetClass);

                /* "cuda/bindings/_internal/_nvml.pyx":2101
 *         global __nvmlVgpuTypeGetClass
 *         __nvmlVgpuTypeGetClass = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetClass')
 *         if __nvmlVgpuTypeGetClass == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetClass == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2102
 *         __nvmlVgpuTypeGetClass = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetClass')
 *         if __nvmlVgpuTypeGetClass == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetClass = dlsym(handle, 'nvmlVgpuTypeGetClass')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2103
 *         if __nvmlVgpuTypeGetClass == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuTypeGetClass = dlsym(handle, 'nvmlVgpuTypeGetClass')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2103, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2102
 *         __nvmlVgpuTypeGetClass = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetClass')
 *         if __nvmlVgpuTypeGetClass == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetClass = dlsym(handle, 'nvmlVgpuTypeGetClass')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2104
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetClass = dlsym(handle, 'nvmlVgpuTypeGetClass')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuTypeGetName
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetClass = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuTypeGetClass);

                  /* "cuda/bindings/_internal/_nvml.pyx":2101
 *         global __nvmlVgpuTypeGetClass
 *         __nvmlVgpuTypeGetClass = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetClass')
 *         if __nvmlVgpuTypeGetClass == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2107
 * 
 *         global __nvmlVgpuTypeGetName
 *         __nvmlVgpuTypeGetName = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetName')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuTypeGetName == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetName = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuTypeGetName);

                /* "cuda/bindings/_internal/_nvml.pyx":2108
 *         global __nvmlVgpuTypeGetName
 *         __nvmlVgpuTypeGetName = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetName')
 *         if __nvmlVgpuTypeGetName == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetName == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2109
 *         __nvmlVgpuTypeGetName = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetName')
 *         if __nvmlVgpuTypeGetName == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetName = dlsym(handle, 'nvmlVgpuTypeGetName')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2110
 *         if __nvmlVgpuTypeGetName == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuTypeGetName = dlsym(handle, 'nvmlVgpuTypeGetName')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2110, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2109
 *         __nvmlVgpuTypeGetName = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetName')
 *         if __nvmlVgpuTypeGetName == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetName = dlsym(handle, 'nvmlVgpuTypeGetName')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2111
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetName = dlsym(handle, 'nvmlVgpuTypeGetName')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuTypeGetGpuInstanceProfileId
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetName = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuTypeGetName);

                  /* "cuda/bindings/_internal/_nvml.pyx":2108
 *         global __nvmlVgpuTypeGetName
 *         __nvmlVgpuTypeGetName = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetName')
 *         if __nvmlVgpuTypeGetName == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2114
 * 
 *         global __nvmlVgpuTypeGetGpuInstanceProfileId
 *         __nvmlVgpuTypeGetGpuInstanceProfileId = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetGpuInstanceProfileId')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuTypeGetGpuInstanceProfileId == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetGpuInstanceProfileId = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuTypeGetGpuInstanceProfil);

                /* "cuda/bindings/_internal/_nvml.pyx":2115
 *         global __nvmlVgpuTypeGetGpuInstanceProfileId
 *         __nvmlVgpuTypeGetGpuInstanceProfileId = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetGpuInstanceProfileId')
 *         if __nvmlVgpuTypeGetGpuInstanceProfileId == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetGpuInstanceProfileId == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2116
 *         __nvmlVgpuTypeGetGpuInstanceProfileId = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetGpuInstanceProfileId')
 *         if __nvmlVgpuTypeGetGpuInstanceProfileId == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetGpuInstanceProfileId = dlsym(handle, 'nvmlVgpuTypeGetGpuInstanceProfileId')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2117
 *         if __nvmlVgpuTypeGetGpuInstanceProfileId == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuTypeGetGpuInstanceProfileId = dlsym(handle, 'nvmlVgpuTypeGetGpuInstanceProfileId')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2117, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2116
 *         __nvmlVgpuTypeGetGpuInstanceProfileId = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetGpuInstanceProfileId')
 *         if __nvmlVgpuTypeGetGpuInstanceProfileId == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetGpuInstanceProfileId = dlsym(handle, 'nvmlVgpuTypeGetGpuInstanceProfileId')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2118
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetGpuInstanceProfileId = dlsym(handle, 'nvmlVgpuTypeGetGpuInstanceProfileId')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuTypeGetDeviceID
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetGpuInstanceProfileId = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuTypeGetGpuInstanceProfil);

                  /* "cuda/bindings/_internal/_nvml.pyx":2115
 *         global __nvmlVgpuTypeGetGpuInstanceProfileId
 *         __nvmlVgpuTypeGetGpuInstanceProfileId = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetGpuInstanceProfileId')
 *         if __nvmlVgpuTypeGetGpuInstanceProfileId == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2121
 * 
 *         global __nvmlVgpuTypeGetDeviceID
 *         __nvmlVgpuTypeGetDeviceID = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetDeviceID')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuTypeGetDeviceID == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetDeviceID = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuTypeGetDeviceID);

                /* "cuda/bindings/_internal/_nvml.pyx":2122
 *         global __nvmlVgpuTypeGetDeviceID
 *         __nvmlVgpuTypeGetDeviceID = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetDeviceID')
 *         if __nvmlVgpuTypeGetDeviceID == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetDeviceID == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2123
 *         __nvmlVgpuTypeGetDeviceID = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetDeviceID')
 *         if __nvmlVgpuTypeGetDeviceID == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetDeviceID = dlsym(handle, 'nvmlVgpuTypeGetDeviceID')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2124
 *         if __nvmlVgpuTypeGetDeviceID == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuTypeGetDeviceID = dlsym(handle, 'nvmlVgpuTypeGetDeviceID')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2124, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2123
 *         __nvmlVgpuTypeGetDeviceID = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetDeviceID')
 *         if __nvmlVgpuTypeGetDeviceID == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetDeviceID = dlsym(handle, 'nvmlVgpuTypeGetDeviceID')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2125
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetDeviceID = dlsym(handle, 'nvmlVgpuTypeGetDeviceID')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuTypeGetFramebufferSize
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetDeviceID = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuTypeGetDeviceID);

                  /* "cuda/bindings/_internal/_nvml.pyx":2122
 *         global __nvmlVgpuTypeGetDeviceID
 *         __nvmlVgpuTypeGetDeviceID = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetDeviceID')
 *         if __nvmlVgpuTypeGetDeviceID == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2128
 * 
 *         global __nvmlVgpuTypeGetFramebufferSize
 *         __nvmlVgpuTypeGetFramebufferSize = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetFramebufferSize')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuTypeGetFramebufferSize == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetFramebufferSize = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuTypeGetFramebufferSize);

                /* "cuda/bindings/_internal/_nvml.pyx":2129
 *         global __nvmlVgpuTypeGetFramebufferSize
 *         __nvmlVgpuTypeGetFramebufferSize = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetFramebufferSize')
 *         if __nvmlVgpuTypeGetFramebufferSize == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetFramebufferSize == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2130
 *         __nvmlVgpuTypeGetFramebufferSize = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetFramebufferSize')
 *         if __nvmlVgpuTypeGetFramebufferSize == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetFramebufferSize = dlsym(handle, 'nvmlVgpuTypeGetFramebufferSize')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2131
 *         if __nvmlVgpuTypeGetFramebufferSize == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuTypeGetFramebufferSize = dlsym(handle, 'nvmlVgpuTypeGetFramebufferSize')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2131, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2130
 *         __nvmlVgpuTypeGetFramebufferSize = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetFramebufferSize')
 *         if __nvmlVgpuTypeGetFramebufferSize == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetFramebufferSize = dlsym(handle, 'nvmlVgpuTypeGetFramebufferSize')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2132
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetFramebufferSize = dlsym(handle, 'nvmlVgpuTypeGetFramebufferSize')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuTypeGetNumDisplayHeads
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetFramebufferSize = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuTypeGetFramebufferSize);

                  /* "cuda/bindings/_internal/_nvml.pyx":2129
 *         global __nvmlVgpuTypeGetFramebufferSize
 *         __nvmlVgpuTypeGetFramebufferSize = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetFramebufferSize')
 *         if __nvmlVgpuTypeGetFramebufferSize == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2135
 * 
 *         global __nvmlVgpuTypeGetNumDisplayHeads
 *         __nvmlVgpuTypeGetNumDisplayHeads = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetNumDisplayHeads')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuTypeGetNumDisplayHeads == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetNumDisplayHeads = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuTypeGetNumDisplayHeads);

                /* "cuda/bindings/_internal/_nvml.pyx":2136
 *         global __nvmlVgpuTypeGetNumDisplayHeads
 *         __nvmlVgpuTypeGetNumDisplayHeads = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetNumDisplayHeads')
 *         if __nvmlVgpuTypeGetNumDisplayHeads == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetNumDisplayHeads == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2137
 *         __nvmlVgpuTypeGetNumDisplayHeads = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetNumDisplayHeads')
 *         if __nvmlVgpuTypeGetNumDisplayHeads == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetNumDisplayHeads = dlsym(handle, 'nvmlVgpuTypeGetNumDisplayHeads')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2138
 *         if __nvmlVgpuTypeGetNumDisplayHeads == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuTypeGetNumDisplayHeads = dlsym(handle, 'nvmlVgpuTypeGetNumDisplayHeads')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2138, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2137
 *         __nvmlVgpuTypeGetNumDisplayHeads = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetNumDisplayHeads')
 *         if __nvmlVgpuTypeGetNumDisplayHeads == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetNumDisplayHeads = dlsym(handle, 'nvmlVgpuTypeGetNumDisplayHeads')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2139
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetNumDisplayHeads = dlsym(handle, 'nvmlVgpuTypeGetNumDisplayHeads')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuTypeGetResolution
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetNumDisplayHeads = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuTypeGetNumDisplayHeads);

                  /* "cuda/bindings/_internal/_nvml.pyx":2136
 *         global __nvmlVgpuTypeGetNumDisplayHeads
 *         __nvmlVgpuTypeGetNumDisplayHeads = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetNumDisplayHeads')
 *         if __nvmlVgpuTypeGetNumDisplayHeads == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2142
 * 
 *         global __nvmlVgpuTypeGetResolution
 *         __nvmlVgpuTypeGetResolution = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetResolution')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuTypeGetResolution == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetResolution = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuTypeGetResolution);

                /* "cuda/bindings/_internal/_nvml.pyx":2143
 *         global __nvmlVgpuTypeGetResolution
 *         __nvmlVgpuTypeGetResolution = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetResolution')
 *         if __nvmlVgpuTypeGetResolution == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetResolution == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2144
 *         __nvmlVgpuTypeGetResolution = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetResolution')
 *         if __nvmlVgpuTypeGetResolution == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetResolution = dlsym(handle, 'nvmlVgpuTypeGetResolution')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2145
 *         if __nvmlVgpuTypeGetResolution == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuTypeGetResolution = dlsym(handle, 'nvmlVgpuTypeGetResolution')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2145, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2144
 *         __nvmlVgpuTypeGetResolution = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetResolution')
 *         if __nvmlVgpuTypeGetResolution == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetResolution = dlsym(handle, 'nvmlVgpuTypeGetResolution')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2146
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetResolution = dlsym(handle, 'nvmlVgpuTypeGetResolution')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuTypeGetLicense
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetResolution = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuTypeGetResolution);

                  /* "cuda/bindings/_internal/_nvml.pyx":2143
 *         global __nvmlVgpuTypeGetResolution
 *         __nvmlVgpuTypeGetResolution = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetResolution')
 *         if __nvmlVgpuTypeGetResolution == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2149
 * 
 *         global __nvmlVgpuTypeGetLicense
 *         __nvmlVgpuTypeGetLicense = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetLicense')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuTypeGetLicense == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetLicense = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuTypeGetLicense);

                /* "cuda/bindings/_internal/_nvml.pyx":2150
 *         global __nvmlVgpuTypeGetLicense
 *         __nvmlVgpuTypeGetLicense = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetLicense')
 *         if __nvmlVgpuTypeGetLicense == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetLicense == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2151
 *         __nvmlVgpuTypeGetLicense = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetLicense')
 *         if __nvmlVgpuTypeGetLicense == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetLicense = dlsym(handle, 'nvmlVgpuTypeGetLicense')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2152
 *         if __nvmlVgpuTypeGetLicense == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuTypeGetLicense = dlsym(handle, 'nvmlVgpuTypeGetLicense')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2152, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2151
 *         __nvmlVgpuTypeGetLicense = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetLicense')
 *         if __nvmlVgpuTypeGetLicense == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetLicense = dlsym(handle, 'nvmlVgpuTypeGetLicense')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2153
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetLicense = dlsym(handle, 'nvmlVgpuTypeGetLicense')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuTypeGetFrameRateLimit
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetLicense = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuTypeGetLicense);

                  /* "cuda/bindings/_internal/_nvml.pyx":2150
 *         global __nvmlVgpuTypeGetLicense
 *         __nvmlVgpuTypeGetLicense = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetLicense')
 *         if __nvmlVgpuTypeGetLicense == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2156
 * 
 *         global __nvmlVgpuTypeGetFrameRateLimit
 *         __nvmlVgpuTypeGetFrameRateLimit = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetFrameRateLimit')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuTypeGetFrameRateLimit == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetFrameRateLimit = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuTypeGetFrameRateLimit);

                /* "cuda/bindings/_internal/_nvml.pyx":2157
 *         global __nvmlVgpuTypeGetFrameRateLimit
 *         __nvmlVgpuTypeGetFrameRateLimit = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetFrameRateLimit')
 *         if __nvmlVgpuTypeGetFrameRateLimit == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetFrameRateLimit == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2158
 *         __nvmlVgpuTypeGetFrameRateLimit = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetFrameRateLimit')
 *         if __nvmlVgpuTypeGetFrameRateLimit == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetFrameRateLimit = dlsym(handle, 'nvmlVgpuTypeGetFrameRateLimit')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2159
 *         if __nvmlVgpuTypeGetFrameRateLimit == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuTypeGetFrameRateLimit = dlsym(handle, 'nvmlVgpuTypeGetFrameRateLimit')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2159, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2158
 *         __nvmlVgpuTypeGetFrameRateLimit = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetFrameRateLimit')
 *         if __nvmlVgpuTypeGetFrameRateLimit == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetFrameRateLimit = dlsym(handle, 'nvmlVgpuTypeGetFrameRateLimit')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2160
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetFrameRateLimit = dlsym(handle, 'nvmlVgpuTypeGetFrameRateLimit')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuTypeGetMaxInstances
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetFrameRateLimit = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuTypeGetFrameRateLimit);

                  /* "cuda/bindings/_internal/_nvml.pyx":2157
 *         global __nvmlVgpuTypeGetFrameRateLimit
 *         __nvmlVgpuTypeGetFrameRateLimit = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetFrameRateLimit')
 *         if __nvmlVgpuTypeGetFrameRateLimit == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2163
 * 
 *         global __nvmlVgpuTypeGetMaxInstances
 *         __nvmlVgpuTypeGetMaxInstances = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetMaxInstances')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuTypeGetMaxInstances == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetMaxInstances = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuTypeGetMaxInstances);

                /* "cuda/bindings/_internal/_nvml.pyx":2164
 *         global __nvmlVgpuTypeGetMaxInstances
 *         __nvmlVgpuTypeGetMaxInstances = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetMaxInstances')
 *         if __nvmlVgpuTypeGetMaxInstances == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetMaxInstances == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2165
 *         __nvmlVgpuTypeGetMaxInstances = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetMaxInstances')
 *         if __nvmlVgpuTypeGetMaxInstances == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetMaxInstances = dlsym(handle, 'nvmlVgpuTypeGetMaxInstances')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2166
 *         if __nvmlVgpuTypeGetMaxInstances == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuTypeGetMaxInstances = dlsym(handle, 'nvmlVgpuTypeGetMaxInstances')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2166, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2165
 *         __nvmlVgpuTypeGetMaxInstances = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetMaxInstances')
 *         if __nvmlVgpuTypeGetMaxInstances == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetMaxInstances = dlsym(handle, 'nvmlVgpuTypeGetMaxInstances')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2167
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetMaxInstances = dlsym(handle, 'nvmlVgpuTypeGetMaxInstances')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuTypeGetMaxInstancesPerVm
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetMaxInstances = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuTypeGetMaxInstances);

                  /* "cuda/bindings/_internal/_nvml.pyx":2164
 *         global __nvmlVgpuTypeGetMaxInstances
 *         __nvmlVgpuTypeGetMaxInstances = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetMaxInstances')
 *         if __nvmlVgpuTypeGetMaxInstances == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2170
 * 
 *         global __nvmlVgpuTypeGetMaxInstancesPerVm
 *         __nvmlVgpuTypeGetMaxInstancesPerVm = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetMaxInstancesPerVm')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuTypeGetMaxInstancesPerVm == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetMaxInstancesPerVm = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuTypeGetMaxInstancesPerVm);

                /* "cuda/bindings/_internal/_nvml.pyx":2171
 *         global __nvmlVgpuTypeGetMaxInstancesPerVm
 *         __nvmlVgpuTypeGetMaxInstancesPerVm = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetMaxInstancesPerVm')
 *         if __nvmlVgpuTypeGetMaxInstancesPerVm == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetMaxInstancesPerVm == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2172
 *         __nvmlVgpuTypeGetMaxInstancesPerVm = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetMaxInstancesPerVm')
 *         if __nvmlVgpuTypeGetMaxInstancesPerVm == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetMaxInstancesPerVm = dlsym(handle, 'nvmlVgpuTypeGetMaxInstancesPerVm')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2173
 *         if __nvmlVgpuTypeGetMaxInstancesPerVm == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuTypeGetMaxInstancesPerVm = dlsym(handle, 'nvmlVgpuTypeGetMaxInstancesPerVm')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2173, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2172
 *         __nvmlVgpuTypeGetMaxInstancesPerVm = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetMaxInstancesPerVm')
 *         if __nvmlVgpuTypeGetMaxInstancesPerVm == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetMaxInstancesPerVm = dlsym(handle, 'nvmlVgpuTypeGetMaxInstancesPerVm')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2174
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetMaxInstancesPerVm = dlsym(handle, 'nvmlVgpuTypeGetMaxInstancesPerVm')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuTypeGetBAR1Info
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetMaxInstancesPerVm = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuTypeGetMaxInstancesPerVm);

                  /* "cuda/bindings/_internal/_nvml.pyx":2171
 *         global __nvmlVgpuTypeGetMaxInstancesPerVm
 *         __nvmlVgpuTypeGetMaxInstancesPerVm = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetMaxInstancesPerVm')
 *         if __nvmlVgpuTypeGetMaxInstancesPerVm == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2177
 * 
 *         global __nvmlVgpuTypeGetBAR1Info
 *         __nvmlVgpuTypeGetBAR1Info = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetBAR1Info')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuTypeGetBAR1Info == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetBAR1Info = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuTypeGetBAR1Info);

                /* "cuda/bindings/_internal/_nvml.pyx":2178
 *         global __nvmlVgpuTypeGetBAR1Info
 *         __nvmlVgpuTypeGetBAR1Info = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetBAR1Info')
 *         if __nvmlVgpuTypeGetBAR1Info == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetBAR1Info == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2179
 *         __nvmlVgpuTypeGetBAR1Info = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetBAR1Info')
 *         if __nvmlVgpuTypeGetBAR1Info == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetBAR1Info = dlsym(handle, 'nvmlVgpuTypeGetBAR1Info')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2180
 *         if __nvmlVgpuTypeGetBAR1Info == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuTypeGetBAR1Info = dlsym(handle, 'nvmlVgpuTypeGetBAR1Info')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2180, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2179
 *         __nvmlVgpuTypeGetBAR1Info = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetBAR1Info')
 *         if __nvmlVgpuTypeGetBAR1Info == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetBAR1Info = dlsym(handle, 'nvmlVgpuTypeGetBAR1Info')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2181
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetBAR1Info = dlsym(handle, 'nvmlVgpuTypeGetBAR1Info')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetActiveVgpus
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetBAR1Info = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuTypeGetBAR1Info);

                  /* "cuda/bindings/_internal/_nvml.pyx":2178
 *         global __nvmlVgpuTypeGetBAR1Info
 *         __nvmlVgpuTypeGetBAR1Info = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetBAR1Info')
 *         if __nvmlVgpuTypeGetBAR1Info == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2184
 * 
 *         global __nvmlDeviceGetActiveVgpus
 *         __nvmlDeviceGetActiveVgpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetActiveVgpus')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetActiveVgpus == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetActiveVgpus = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetActiveVgpus);

                /* "cuda/bindings/_internal/_nvml.pyx":2185
 *         global __nvmlDeviceGetActiveVgpus
 *         __nvmlDeviceGetActiveVgpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetActiveVgpus')
 *         if __nvmlDeviceGetActiveVgpus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetActiveVgpus == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2186
 *         __nvmlDeviceGetActiveVgpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetActiveVgpus')
 *         if __nvmlDeviceGetActiveVgpus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetActiveVgpus = dlsym(handle, 'nvmlDeviceGetActiveVgpus')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2187
 *         if __nvmlDeviceGetActiveVgpus == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetActiveVgpus = dlsym(handle, 'nvmlDeviceGetActiveVgpus')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2187, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2186
 *         __nvmlDeviceGetActiveVgpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetActiveVgpus')
 *         if __nvmlDeviceGetActiveVgpus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetActiveVgpus = dlsym(handle, 'nvmlDeviceGetActiveVgpus')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2188
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetActiveVgpus = dlsym(handle, 'nvmlDeviceGetActiveVgpus')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceGetVmID
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetActiveVgpus = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetActiveVgpus);

                  /* "cuda/bindings/_internal/_nvml.pyx":2185
 *         global __nvmlDeviceGetActiveVgpus
 *         __nvmlDeviceGetActiveVgpus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetActiveVgpus')
 *         if __nvmlDeviceGetActiveVgpus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2191
 * 
 *         global __nvmlVgpuInstanceGetVmID
 *         __nvmlVgpuInstanceGetVmID = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetVmID')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceGetVmID == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetVmID = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceGetVmID);

                /* "cuda/bindings/_internal/_nvml.pyx":2192
 *         global __nvmlVgpuInstanceGetVmID
 *         __nvmlVgpuInstanceGetVmID = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetVmID')
 *         if __nvmlVgpuInstanceGetVmID == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetVmID == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2193
 *         __nvmlVgpuInstanceGetVmID = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetVmID')
 *         if __nvmlVgpuInstanceGetVmID == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetVmID = dlsym(handle, 'nvmlVgpuInstanceGetVmID')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2194
 *         if __nvmlVgpuInstanceGetVmID == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceGetVmID = dlsym(handle, 'nvmlVgpuInstanceGetVmID')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2194, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2193
 *         __nvmlVgpuInstanceGetVmID = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetVmID')
 *         if __nvmlVgpuInstanceGetVmID == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetVmID = dlsym(handle, 'nvmlVgpuInstanceGetVmID')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2195
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetVmID = dlsym(handle, 'nvmlVgpuInstanceGetVmID')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceGetUUID
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetVmID = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceGetVmID);

                  /* "cuda/bindings/_internal/_nvml.pyx":2192
 *         global __nvmlVgpuInstanceGetVmID
 *         __nvmlVgpuInstanceGetVmID = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetVmID')
 *         if __nvmlVgpuInstanceGetVmID == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2198
 * 
 *         global __nvmlVgpuInstanceGetUUID
 *         __nvmlVgpuInstanceGetUUID = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetUUID')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceGetUUID == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetUUID = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceGetUUID);

                /* "cuda/bindings/_internal/_nvml.pyx":2199
 *         global __nvmlVgpuInstanceGetUUID
 *         __nvmlVgpuInstanceGetUUID = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetUUID')
 *         if __nvmlVgpuInstanceGetUUID == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetUUID == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2200
 *         __nvmlVgpuInstanceGetUUID = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetUUID')
 *         if __nvmlVgpuInstanceGetUUID == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetUUID = dlsym(handle, 'nvmlVgpuInstanceGetUUID')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2201
 *         if __nvmlVgpuInstanceGetUUID == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceGetUUID = dlsym(handle, 'nvmlVgpuInstanceGetUUID')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2201, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2200
 *         __nvmlVgpuInstanceGetUUID = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetUUID')
 *         if __nvmlVgpuInstanceGetUUID == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetUUID = dlsym(handle, 'nvmlVgpuInstanceGetUUID')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2202
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetUUID = dlsym(handle, 'nvmlVgpuInstanceGetUUID')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceGetVmDriverVersion
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetUUID = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceGetUUID);

                  /* "cuda/bindings/_internal/_nvml.pyx":2199
 *         global __nvmlVgpuInstanceGetUUID
 *         __nvmlVgpuInstanceGetUUID = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetUUID')
 *         if __nvmlVgpuInstanceGetUUID == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2205
 * 
 *         global __nvmlVgpuInstanceGetVmDriverVersion
 *         __nvmlVgpuInstanceGetVmDriverVersion = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetVmDriverVersion')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceGetVmDriverVersion == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetVmDriverVersion = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceGetVmDriverVersi);

                /* "cuda/bindings/_internal/_nvml.pyx":2206
 *         global __nvmlVgpuInstanceGetVmDriverVersion
 *         __nvmlVgpuInstanceGetVmDriverVersion = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetVmDriverVersion')
 *         if __nvmlVgpuInstanceGetVmDriverVersion == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetVmDriverVersion == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2207
 *         __nvmlVgpuInstanceGetVmDriverVersion = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetVmDriverVersion')
 *         if __nvmlVgpuInstanceGetVmDriverVersion == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetVmDriverVersion = dlsym(handle, 'nvmlVgpuInstanceGetVmDriverVersion')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2208
 *         if __nvmlVgpuInstanceGetVmDriverVersion == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceGetVmDriverVersion = dlsym(handle, 'nvmlVgpuInstanceGetVmDriverVersion')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2208, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2207
 *         __nvmlVgpuInstanceGetVmDriverVersion = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetVmDriverVersion')
 *         if __nvmlVgpuInstanceGetVmDriverVersion == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetVmDriverVersion = dlsym(handle, 'nvmlVgpuInstanceGetVmDriverVersion')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2209
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetVmDriverVersion = dlsym(handle, 'nvmlVgpuInstanceGetVmDriverVersion')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceGetFbUsage
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetVmDriverVersion = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceGetVmDriverVersi);

                  /* "cuda/bindings/_internal/_nvml.pyx":2206
 *         global __nvmlVgpuInstanceGetVmDriverVersion
 *         __nvmlVgpuInstanceGetVmDriverVersion = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetVmDriverVersion')
 *         if __nvmlVgpuInstanceGetVmDriverVersion == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2212
 * 
 *         global __nvmlVgpuInstanceGetFbUsage
 *         __nvmlVgpuInstanceGetFbUsage = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetFbUsage')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceGetFbUsage == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFbUsage = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceGetFbUsage);

                /* "cuda/bindings/_internal/_nvml.pyx":2213
 *         global __nvmlVgpuInstanceGetFbUsage
 *         __nvmlVgpuInstanceGetFbUsage = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetFbUsage')
 *         if __nvmlVgpuInstanceGetFbUsage == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFbUsage == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2214
 *         __nvmlVgpuInstanceGetFbUsage = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetFbUsage')
 *         if __nvmlVgpuInstanceGetFbUsage == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetFbUsage = dlsym(handle, 'nvmlVgpuInstanceGetFbUsage')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2215
 *         if __nvmlVgpuInstanceGetFbUsage == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceGetFbUsage = dlsym(handle, 'nvmlVgpuInstanceGetFbUsage')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2215, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2214
 *         __nvmlVgpuInstanceGetFbUsage = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetFbUsage')
 *         if __nvmlVgpuInstanceGetFbUsage == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetFbUsage = dlsym(handle, 'nvmlVgpuInstanceGetFbUsage')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2216
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetFbUsage = dlsym(handle, 'nvmlVgpuInstanceGetFbUsage')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceGetLicenseStatus
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFbUsage = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceGetFbUsage);

                  /* "cuda/bindings/_internal/_nvml.pyx":2213
 *         global __nvmlVgpuInstanceGetFbUsage
 *         __nvmlVgpuInstanceGetFbUsage = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetFbUsage')
 *         if __nvmlVgpuInstanceGetFbUsage == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2219
 * 
 *         global __nvmlVgpuInstanceGetLicenseStatus
 *         __nvmlVgpuInstanceGetLicenseStatus = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetLicenseStatus')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceGetLicenseStatus == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetLicenseStatus = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceGetLicenseStatus);

                /* "cuda/bindings/_internal/_nvml.pyx":2220
 *         global __nvmlVgpuInstanceGetLicenseStatus
 *         __nvmlVgpuInstanceGetLicenseStatus = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetLicenseStatus')
 *         if __nvmlVgpuInstanceGetLicenseStatus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetLicenseStatus == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2221
 *         __nvmlVgpuInstanceGetLicenseStatus = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetLicenseStatus')
 *         if __nvmlVgpuInstanceGetLicenseStatus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetLicenseStatus = dlsym(handle, 'nvmlVgpuInstanceGetLicenseStatus')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2222
 *         if __nvmlVgpuInstanceGetLicenseStatus == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceGetLicenseStatus = dlsym(handle, 'nvmlVgpuInstanceGetLicenseStatus')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2222, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2221
 *         __nvmlVgpuInstanceGetLicenseStatus = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetLicenseStatus')
 *         if __nvmlVgpuInstanceGetLicenseStatus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetLicenseStatus = dlsym(handle, 'nvmlVgpuInstanceGetLicenseStatus')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2223
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetLicenseStatus = dlsym(handle, 'nvmlVgpuInstanceGetLicenseStatus')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceGetType
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetLicenseStatus = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceGetLicenseStatus);

                  /* "cuda/bindings/_internal/_nvml.pyx":2220
 *         global __nvmlVgpuInstanceGetLicenseStatus
 *         __nvmlVgpuInstanceGetLicenseStatus = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetLicenseStatus')
 *         if __nvmlVgpuInstanceGetLicenseStatus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2226
 * 
 *         global __nvmlVgpuInstanceGetType
 *         __nvmlVgpuInstanceGetType = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetType')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceGetType == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetType = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceGetType);

                /* "cuda/bindings/_internal/_nvml.pyx":2227
 *         global __nvmlVgpuInstanceGetType
 *         __nvmlVgpuInstanceGetType = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetType')
 *         if __nvmlVgpuInstanceGetType == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetType == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2228
 *         __nvmlVgpuInstanceGetType = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetType')
 *         if __nvmlVgpuInstanceGetType == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetType = dlsym(handle, 'nvmlVgpuInstanceGetType')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2229
 *         if __nvmlVgpuInstanceGetType == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceGetType = dlsym(handle, 'nvmlVgpuInstanceGetType')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2229, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2228
 *         __nvmlVgpuInstanceGetType = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetType')
 *         if __nvmlVgpuInstanceGetType == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetType = dlsym(handle, 'nvmlVgpuInstanceGetType')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2230
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetType = dlsym(handle, 'nvmlVgpuInstanceGetType')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceGetFrameRateLimit
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetType = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceGetType);

                  /* "cuda/bindings/_internal/_nvml.pyx":2227
 *         global __nvmlVgpuInstanceGetType
 *         __nvmlVgpuInstanceGetType = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetType')
 *         if __nvmlVgpuInstanceGetType == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2233
 * 
 *         global __nvmlVgpuInstanceGetFrameRateLimit
 *         __nvmlVgpuInstanceGetFrameRateLimit = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetFrameRateLimit')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceGetFrameRateLimit == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFrameRateLimit = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceGetFrameRateLimi);

                /* "cuda/bindings/_internal/_nvml.pyx":2234
 *         global __nvmlVgpuInstanceGetFrameRateLimit
 *         __nvmlVgpuInstanceGetFrameRateLimit = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetFrameRateLimit')
 *         if __nvmlVgpuInstanceGetFrameRateLimit == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFrameRateLimit == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2235
 *         __nvmlVgpuInstanceGetFrameRateLimit = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetFrameRateLimit')
 *         if __nvmlVgpuInstanceGetFrameRateLimit == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetFrameRateLimit = dlsym(handle, 'nvmlVgpuInstanceGetFrameRateLimit')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2236
 *         if __nvmlVgpuInstanceGetFrameRateLimit == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceGetFrameRateLimit = dlsym(handle, 'nvmlVgpuInstanceGetFrameRateLimit')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2236, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2235
 *         __nvmlVgpuInstanceGetFrameRateLimit = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetFrameRateLimit')
 *         if __nvmlVgpuInstanceGetFrameRateLimit == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetFrameRateLimit = dlsym(handle, 'nvmlVgpuInstanceGetFrameRateLimit')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2237
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetFrameRateLimit = dlsym(handle, 'nvmlVgpuInstanceGetFrameRateLimit')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceGetEccMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFrameRateLimit = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceGetFrameRateLimi);

                  /* "cuda/bindings/_internal/_nvml.pyx":2234
 *         global __nvmlVgpuInstanceGetFrameRateLimit
 *         __nvmlVgpuInstanceGetFrameRateLimit = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetFrameRateLimit')
 *         if __nvmlVgpuInstanceGetFrameRateLimit == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2240
 * 
 *         global __nvmlVgpuInstanceGetEccMode
 *         __nvmlVgpuInstanceGetEccMode = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetEccMode')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceGetEccMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEccMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceGetEccMode);

                /* "cuda/bindings/_internal/_nvml.pyx":2241
 *         global __nvmlVgpuInstanceGetEccMode
 *         __nvmlVgpuInstanceGetEccMode = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetEccMode')
 *         if __nvmlVgpuInstanceGetEccMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEccMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2242
 *         __nvmlVgpuInstanceGetEccMode = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetEccMode')
 *         if __nvmlVgpuInstanceGetEccMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetEccMode = dlsym(handle, 'nvmlVgpuInstanceGetEccMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2243
 *         if __nvmlVgpuInstanceGetEccMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceGetEccMode = dlsym(handle, 'nvmlVgpuInstanceGetEccMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2243, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2242
 *         __nvmlVgpuInstanceGetEccMode = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetEccMode')
 *         if __nvmlVgpuInstanceGetEccMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetEccMode = dlsym(handle, 'nvmlVgpuInstanceGetEccMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2244
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetEccMode = dlsym(handle, 'nvmlVgpuInstanceGetEccMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceGetEncoderCapacity
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEccMode = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceGetEccMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":2241
 *         global __nvmlVgpuInstanceGetEccMode
 *         __nvmlVgpuInstanceGetEccMode = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetEccMode')
 *         if __nvmlVgpuInstanceGetEccMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2247
 * 
 *         global __nvmlVgpuInstanceGetEncoderCapacity
 *         __nvmlVgpuInstanceGetEncoderCapacity = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetEncoderCapacity')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceGetEncoderCapacity == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEncoderCapacity = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceGetEncoderCapaci);

                /* "cuda/bindings/_internal/_nvml.pyx":2248
 *         global __nvmlVgpuInstanceGetEncoderCapacity
 *         __nvmlVgpuInstanceGetEncoderCapacity = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetEncoderCapacity')
 *         if __nvmlVgpuInstanceGetEncoderCapacity == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEncoderCapacity == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2249
 *         __nvmlVgpuInstanceGetEncoderCapacity = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetEncoderCapacity')
 *         if __nvmlVgpuInstanceGetEncoderCapacity == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetEncoderCapacity = dlsym(handle, 'nvmlVgpuInstanceGetEncoderCapacity')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2250
 *         if __nvmlVgpuInstanceGetEncoderCapacity == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceGetEncoderCapacity = dlsym(handle, 'nvmlVgpuInstanceGetEncoderCapacity')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2250, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2249
 *         __nvmlVgpuInstanceGetEncoderCapacity = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetEncoderCapacity')
 *         if __nvmlVgpuInstanceGetEncoderCapacity == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetEncoderCapacity = dlsym(handle, 'nvmlVgpuInstanceGetEncoderCapacity')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2251
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetEncoderCapacity = dlsym(handle, 'nvmlVgpuInstanceGetEncoderCapacity')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceSetEncoderCapacity
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEncoderCapacity = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceGetEncoderCapaci);

                  /* "cuda/bindings/_internal/_nvml.pyx":2248
 *         global __nvmlVgpuInstanceGetEncoderCapacity
 *         __nvmlVgpuInstanceGetEncoderCapacity = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetEncoderCapacity')
 *         if __nvmlVgpuInstanceGetEncoderCapacity == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2254
 * 
 *         global __nvmlVgpuInstanceSetEncoderCapacity
 *         __nvmlVgpuInstanceSetEncoderCapacity = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceSetEncoderCapacity')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceSetEncoderCapacity == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceSetEncoderCapacity = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceSetEncoderCapaci);

                /* "cuda/bindings/_internal/_nvml.pyx":2255
 *         global __nvmlVgpuInstanceSetEncoderCapacity
 *         __nvmlVgpuInstanceSetEncoderCapacity = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceSetEncoderCapacity')
 *         if __nvmlVgpuInstanceSetEncoderCapacity == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceSetEncoderCapacity == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2256
 *         __nvmlVgpuInstanceSetEncoderCapacity = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceSetEncoderCapacity')
 *         if __nvmlVgpuInstanceSetEncoderCapacity == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceSetEncoderCapacity = dlsym(handle, 'nvmlVgpuInstanceSetEncoderCapacity')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2257
 *         if __nvmlVgpuInstanceSetEncoderCapacity == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceSetEncoderCapacity = dlsym(handle, 'nvmlVgpuInstanceSetEncoderCapacity')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2257, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2256
 *         __nvmlVgpuInstanceSetEncoderCapacity = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceSetEncoderCapacity')
 *         if __nvmlVgpuInstanceSetEncoderCapacity == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceSetEncoderCapacity = dlsym(handle, 'nvmlVgpuInstanceSetEncoderCapacity')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2258
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceSetEncoderCapacity = dlsym(handle, 'nvmlVgpuInstanceSetEncoderCapacity')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceGetEncoderStats
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceSetEncoderCapacity = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceSetEncoderCapaci);

                  /* "cuda/bindings/_internal/_nvml.pyx":2255
 *         global __nvmlVgpuInstanceSetEncoderCapacity
 *         __nvmlVgpuInstanceSetEncoderCapacity = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceSetEncoderCapacity')
 *         if __nvmlVgpuInstanceSetEncoderCapacity == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2261
 * 
 *         global __nvmlVgpuInstanceGetEncoderStats
 *         __nvmlVgpuInstanceGetEncoderStats = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetEncoderStats')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceGetEncoderStats == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEncoderStats = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceGetEncoderStats);

                /* "cuda/bindings/_internal/_nvml.pyx":2262
 *         global __nvmlVgpuInstanceGetEncoderStats
 *         __nvmlVgpuInstanceGetEncoderStats = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetEncoderStats')
 *         if __nvmlVgpuInstanceGetEncoderStats == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEncoderStats == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2263
 *         __nvmlVgpuInstanceGetEncoderStats = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetEncoderStats')
 *         if __nvmlVgpuInstanceGetEncoderStats == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetEncoderStats = dlsym(handle, 'nvmlVgpuInstanceGetEncoderStats')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2264
 *         if __nvmlVgpuInstanceGetEncoderStats == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceGetEncoderStats = dlsym(handle, 'nvmlVgpuInstanceGetEncoderStats')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2264, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2263
 *         __nvmlVgpuInstanceGetEncoderStats = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetEncoderStats')
 *         if __nvmlVgpuInstanceGetEncoderStats == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetEncoderStats = dlsym(handle, 'nvmlVgpuInstanceGetEncoderStats')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2265
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetEncoderStats = dlsym(handle, 'nvmlVgpuInstanceGetEncoderStats')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceGetEncoderSessions
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEncoderStats = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceGetEncoderStats);

                  /* "cuda/bindings/_internal/_nvml.pyx":2262
 *         global __nvmlVgpuInstanceGetEncoderStats
 *         __nvmlVgpuInstanceGetEncoderStats = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetEncoderStats')
 *         if __nvmlVgpuInstanceGetEncoderStats == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2268
 * 
 *         global __nvmlVgpuInstanceGetEncoderSessions
 *         __nvmlVgpuInstanceGetEncoderSessions = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetEncoderSessions')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceGetEncoderSessions == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEncoderSessions = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceGetEncoderSessio);

                /* "cuda/bindings/_internal/_nvml.pyx":2269
 *         global __nvmlVgpuInstanceGetEncoderSessions
 *         __nvmlVgpuInstanceGetEncoderSessions = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetEncoderSessions')
 *         if __nvmlVgpuInstanceGetEncoderSessions == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEncoderSessions == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2270
 *         __nvmlVgpuInstanceGetEncoderSessions = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetEncoderSessions')
 *         if __nvmlVgpuInstanceGetEncoderSessions == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetEncoderSessions = dlsym(handle, 'nvmlVgpuInstanceGetEncoderSessions')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2271
 *         if __nvmlVgpuInstanceGetEncoderSessions == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceGetEncoderSessions = dlsym(handle, 'nvmlVgpuInstanceGetEncoderSessions')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2271, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2270
 *         __nvmlVgpuInstanceGetEncoderSessions = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetEncoderSessions')
 *         if __nvmlVgpuInstanceGetEncoderSessions == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetEncoderSessions = dlsym(handle, 'nvmlVgpuInstanceGetEncoderSessions')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2272
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetEncoderSessions = dlsym(handle, 'nvmlVgpuInstanceGetEncoderSessions')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceGetFBCStats
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEncoderSessions = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceGetEncoderSessio);

                  /* "cuda/bindings/_internal/_nvml.pyx":2269
 *         global __nvmlVgpuInstanceGetEncoderSessions
 *         __nvmlVgpuInstanceGetEncoderSessions = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetEncoderSessions')
 *         if __nvmlVgpuInstanceGetEncoderSessions == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2275
 * 
 *         global __nvmlVgpuInstanceGetFBCStats
 *         __nvmlVgpuInstanceGetFBCStats = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetFBCStats')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceGetFBCStats == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFBCStats = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceGetFBCStats);

                /* "cuda/bindings/_internal/_nvml.pyx":2276
 *         global __nvmlVgpuInstanceGetFBCStats
 *         __nvmlVgpuInstanceGetFBCStats = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetFBCStats')
 *         if __nvmlVgpuInstanceGetFBCStats == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFBCStats == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2277
 *         __nvmlVgpuInstanceGetFBCStats = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetFBCStats')
 *         if __nvmlVgpuInstanceGetFBCStats == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetFBCStats = dlsym(handle, 'nvmlVgpuInstanceGetFBCStats')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2278
 *         if __nvmlVgpuInstanceGetFBCStats == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceGetFBCStats = dlsym(handle, 'nvmlVgpuInstanceGetFBCStats')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2278, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2277
 *         __nvmlVgpuInstanceGetFBCStats = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetFBCStats')
 *         if __nvmlVgpuInstanceGetFBCStats == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetFBCStats = dlsym(handle, 'nvmlVgpuInstanceGetFBCStats')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2279
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetFBCStats = dlsym(handle, 'nvmlVgpuInstanceGetFBCStats')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceGetFBCSessions
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFBCStats = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceGetFBCStats);

                  /* "cuda/bindings/_internal/_nvml.pyx":2276
 *         global __nvmlVgpuInstanceGetFBCStats
 *         __nvmlVgpuInstanceGetFBCStats = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetFBCStats')
 *         if __nvmlVgpuInstanceGetFBCStats == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2282
 * 
 *         global __nvmlVgpuInstanceGetFBCSessions
 *         __nvmlVgpuInstanceGetFBCSessions = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetFBCSessions')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceGetFBCSessions == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFBCSessions = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceGetFBCSessions);

                /* "cuda/bindings/_internal/_nvml.pyx":2283
 *         global __nvmlVgpuInstanceGetFBCSessions
 *         __nvmlVgpuInstanceGetFBCSessions = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetFBCSessions')
 *         if __nvmlVgpuInstanceGetFBCSessions == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFBCSessions == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2284
 *         __nvmlVgpuInstanceGetFBCSessions = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetFBCSessions')
 *         if __nvmlVgpuInstanceGetFBCSessions == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetFBCSessions = dlsym(handle, 'nvmlVgpuInstanceGetFBCSessions')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2285
 *         if __nvmlVgpuInstanceGetFBCSessions == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceGetFBCSessions = dlsym(handle, 'nvmlVgpuInstanceGetFBCSessions')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2285, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2284
 *         __nvmlVgpuInstanceGetFBCSessions = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetFBCSessions')
 *         if __nvmlVgpuInstanceGetFBCSessions == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetFBCSessions = dlsym(handle, 'nvmlVgpuInstanceGetFBCSessions')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2286
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetFBCSessions = dlsym(handle, 'nvmlVgpuInstanceGetFBCSessions')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceGetGpuInstanceId
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFBCSessions = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceGetFBCSessions);

                  /* "cuda/bindings/_internal/_nvml.pyx":2283
 *         global __nvmlVgpuInstanceGetFBCSessions
 *         __nvmlVgpuInstanceGetFBCSessions = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetFBCSessions')
 *         if __nvmlVgpuInstanceGetFBCSessions == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2289
 * 
 *         global __nvmlVgpuInstanceGetGpuInstanceId
 *         __nvmlVgpuInstanceGetGpuInstanceId = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetGpuInstanceId')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceGetGpuInstanceId == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetGpuInstanceId = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceGetGpuInstanceId);

                /* "cuda/bindings/_internal/_nvml.pyx":2290
 *         global __nvmlVgpuInstanceGetGpuInstanceId
 *         __nvmlVgpuInstanceGetGpuInstanceId = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetGpuInstanceId')
 *         if __nvmlVgpuInstanceGetGpuInstanceId == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetGpuInstanceId == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2291
 *         __nvmlVgpuInstanceGetGpuInstanceId = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetGpuInstanceId')
 *         if __nvmlVgpuInstanceGetGpuInstanceId == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetGpuInstanceId = dlsym(handle, 'nvmlVgpuInstanceGetGpuInstanceId')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2292
 *         if __nvmlVgpuInstanceGetGpuInstanceId == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceGetGpuInstanceId = dlsym(handle, 'nvmlVgpuInstanceGetGpuInstanceId')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2292, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2291
 *         __nvmlVgpuInstanceGetGpuInstanceId = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetGpuInstanceId')
 *         if __nvmlVgpuInstanceGetGpuInstanceId == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetGpuInstanceId = dlsym(handle, 'nvmlVgpuInstanceGetGpuInstanceId')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2293
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetGpuInstanceId = dlsym(handle, 'nvmlVgpuInstanceGetGpuInstanceId')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceGetGpuPciId
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetGpuInstanceId = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceGetGpuInstanceId);

                  /* "cuda/bindings/_internal/_nvml.pyx":2290
 *         global __nvmlVgpuInstanceGetGpuInstanceId
 *         __nvmlVgpuInstanceGetGpuInstanceId = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetGpuInstanceId')
 *         if __nvmlVgpuInstanceGetGpuInstanceId == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2296
 * 
 *         global __nvmlVgpuInstanceGetGpuPciId
 *         __nvmlVgpuInstanceGetGpuPciId = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetGpuPciId')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceGetGpuPciId == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetGpuPciId = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceGetGpuPciId);

                /* "cuda/bindings/_internal/_nvml.pyx":2297
 *         global __nvmlVgpuInstanceGetGpuPciId
 *         __nvmlVgpuInstanceGetGpuPciId = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetGpuPciId')
 *         if __nvmlVgpuInstanceGetGpuPciId == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetGpuPciId == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2298
 *         __nvmlVgpuInstanceGetGpuPciId = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetGpuPciId')
 *         if __nvmlVgpuInstanceGetGpuPciId == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetGpuPciId = dlsym(handle, 'nvmlVgpuInstanceGetGpuPciId')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2299
 *         if __nvmlVgpuInstanceGetGpuPciId == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceGetGpuPciId = dlsym(handle, 'nvmlVgpuInstanceGetGpuPciId')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2299, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2298
 *         __nvmlVgpuInstanceGetGpuPciId = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetGpuPciId')
 *         if __nvmlVgpuInstanceGetGpuPciId == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetGpuPciId = dlsym(handle, 'nvmlVgpuInstanceGetGpuPciId')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2300
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetGpuPciId = dlsym(handle, 'nvmlVgpuInstanceGetGpuPciId')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuTypeGetCapabilities
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetGpuPciId = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceGetGpuPciId);

                  /* "cuda/bindings/_internal/_nvml.pyx":2297
 *         global __nvmlVgpuInstanceGetGpuPciId
 *         __nvmlVgpuInstanceGetGpuPciId = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetGpuPciId')
 *         if __nvmlVgpuInstanceGetGpuPciId == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2303
 * 
 *         global __nvmlVgpuTypeGetCapabilities
 *         __nvmlVgpuTypeGetCapabilities = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetCapabilities')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuTypeGetCapabilities == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetCapabilities = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuTypeGetCapabilities);

                /* "cuda/bindings/_internal/_nvml.pyx":2304
 *         global __nvmlVgpuTypeGetCapabilities
 *         __nvmlVgpuTypeGetCapabilities = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetCapabilities')
 *         if __nvmlVgpuTypeGetCapabilities == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetCapabilities == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2305
 *         __nvmlVgpuTypeGetCapabilities = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetCapabilities')
 *         if __nvmlVgpuTypeGetCapabilities == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetCapabilities = dlsym(handle, 'nvmlVgpuTypeGetCapabilities')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2306
 *         if __nvmlVgpuTypeGetCapabilities == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuTypeGetCapabilities = dlsym(handle, 'nvmlVgpuTypeGetCapabilities')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2306, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2305
 *         __nvmlVgpuTypeGetCapabilities = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetCapabilities')
 *         if __nvmlVgpuTypeGetCapabilities == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetCapabilities = dlsym(handle, 'nvmlVgpuTypeGetCapabilities')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2307
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetCapabilities = dlsym(handle, 'nvmlVgpuTypeGetCapabilities')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceGetMdevUUID
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetCapabilities = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuTypeGetCapabilities);

                  /* "cuda/bindings/_internal/_nvml.pyx":2304
 *         global __nvmlVgpuTypeGetCapabilities
 *         __nvmlVgpuTypeGetCapabilities = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetCapabilities')
 *         if __nvmlVgpuTypeGetCapabilities == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2310
 * 
 *         global __nvmlVgpuInstanceGetMdevUUID
 *         __nvmlVgpuInstanceGetMdevUUID = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetMdevUUID')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceGetMdevUUID == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetMdevUUID = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceGetMdevUUID);

                /* "cuda/bindings/_internal/_nvml.pyx":2311
 *         global __nvmlVgpuInstanceGetMdevUUID
 *         __nvmlVgpuInstanceGetMdevUUID = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetMdevUUID')
 *         if __nvmlVgpuInstanceGetMdevUUID == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetMdevUUID == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2312
 *         __nvmlVgpuInstanceGetMdevUUID = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetMdevUUID')
 *         if __nvmlVgpuInstanceGetMdevUUID == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetMdevUUID = dlsym(handle, 'nvmlVgpuInstanceGetMdevUUID')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2313
 *         if __nvmlVgpuInstanceGetMdevUUID == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceGetMdevUUID = dlsym(handle, 'nvmlVgpuInstanceGetMdevUUID')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2313, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2312
 *         __nvmlVgpuInstanceGetMdevUUID = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetMdevUUID')
 *         if __nvmlVgpuInstanceGetMdevUUID == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetMdevUUID = dlsym(handle, 'nvmlVgpuInstanceGetMdevUUID')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2314
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetMdevUUID = dlsym(handle, 'nvmlVgpuInstanceGetMdevUUID')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGpuInstanceGetCreatableVgpus
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetMdevUUID = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceGetMdevUUID);

                  /* "cuda/bindings/_internal/_nvml.pyx":2311
 *         global __nvmlVgpuInstanceGetMdevUUID
 *         __nvmlVgpuInstanceGetMdevUUID = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetMdevUUID')
 *         if __nvmlVgpuInstanceGetMdevUUID == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2317
 * 
 *         global __nvmlGpuInstanceGetCreatableVgpus
 *         __nvmlGpuInstanceGetCreatableVgpus = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetCreatableVgpus')             # <<<<<<<<<<<<<<
 *         if __nvmlGpuInstanceGetCreatableVgpus == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetCreatableVgpus = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGpuInstanceGetCreatableVgpus);

                /* "cuda/bindings/_internal/_nvml.pyx":2318
 *         global __nvmlGpuInstanceGetCreatableVgpus
 *         __nvmlGpuInstanceGetCreatableVgpus = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetCreatableVgpus')
 *         if __nvmlGpuInstanceGetCreatableVgpus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetCreatableVgpus == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2319
 *         __nvmlGpuInstanceGetCreatableVgpus = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetCreatableVgpus')
 *         if __nvmlGpuInstanceGetCreatableVgpus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetCreatableVgpus = dlsym(handle, 'nvmlGpuInstanceGetCreatableVgpus')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2320
 *         if __nvmlGpuInstanceGetCreatableVgpus == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGpuInstanceGetCreatableVgpus = dlsym(handle, 'nvmlGpuInstanceGetCreatableVgpus')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2320, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2319
 *         __nvmlGpuInstanceGetCreatableVgpus = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetCreatableVgpus')
 *         if __nvmlGpuInstanceGetCreatableVgpus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetCreatableVgpus = dlsym(handle, 'nvmlGpuInstanceGetCreatableVgpus')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2321
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetCreatableVgpus = dlsym(handle, 'nvmlGpuInstanceGetCreatableVgpus')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuTypeGetMaxInstancesPerGpuInstance
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetCreatableVgpus = dlsym(__pyx_v_handle, __pyx_k_nvmlGpuInstanceGetCreatableVgpus);

                  /* "cuda/bindings/_internal/_nvml.pyx":2318
 *         global __nvmlGpuInstanceGetCreatableVgpus
 *         __nvmlGpuInstanceGetCreatableVgpus = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetCreatableVgpus')
 *         if __nvmlGpuInstanceGetCreatableVgpus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2324
 * 
 *         global __nvmlVgpuTypeGetMaxInstancesPerGpuInstance
 *         __nvmlVgpuTypeGetMaxInstancesPerGpuInstance = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetMaxInstancesPerGpuInstance')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuTypeGetMaxInstancesPerGpuInstance == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetMaxInstancesPerGpuInstance = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuTypeGetMaxInstancesPerGp);

                /* "cuda/bindings/_internal/_nvml.pyx":2325
 *         global __nvmlVgpuTypeGetMaxInstancesPerGpuInstance
 *         __nvmlVgpuTypeGetMaxInstancesPerGpuInstance = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetMaxInstancesPerGpuInstance')
 *         if __nvmlVgpuTypeGetMaxInstancesPerGpuInstance == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetMaxInstancesPerGpuInstance == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2326
 *         __nvmlVgpuTypeGetMaxInstancesPerGpuInstance = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetMaxInstancesPerGpuInstance')
 *         if __nvmlVgpuTypeGetMaxInstancesPerGpuInstance == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetMaxInstancesPerGpuInstance = dlsym(handle, 'nvmlVgpuTypeGetMaxInstancesPerGpuInstance')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2327
 *         if __nvmlVgpuTypeGetMaxInstancesPerGpuInstance == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuTypeGetMaxInstancesPerGpuInstance = dlsym(handle, 'nvmlVgpuTypeGetMaxInstancesPerGpuInstance')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2327, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2326
 *         __nvmlVgpuTypeGetMaxInstancesPerGpuInstance = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetMaxInstancesPerGpuInstance')
 *         if __nvmlVgpuTypeGetMaxInstancesPerGpuInstance == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetMaxInstancesPerGpuInstance = dlsym(handle, 'nvmlVgpuTypeGetMaxInstancesPerGpuInstance')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2328
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuTypeGetMaxInstancesPerGpuInstance = dlsym(handle, 'nvmlVgpuTypeGetMaxInstancesPerGpuInstance')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGpuInstanceGetActiveVgpus
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetMaxInstancesPerGpuInstance = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuTypeGetMaxInstancesPerGp);

                  /* "cuda/bindings/_internal/_nvml.pyx":2325
 *         global __nvmlVgpuTypeGetMaxInstancesPerGpuInstance
 *         __nvmlVgpuTypeGetMaxInstancesPerGpuInstance = dlsym(RTLD_DEFAULT, 'nvmlVgpuTypeGetMaxInstancesPerGpuInstance')
 *         if __nvmlVgpuTypeGetMaxInstancesPerGpuInstance == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2331
 * 
 *         global __nvmlGpuInstanceGetActiveVgpus
 *         __nvmlGpuInstanceGetActiveVgpus = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetActiveVgpus')             # <<<<<<<<<<<<<<
 *         if __nvmlGpuInstanceGetActiveVgpus == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetActiveVgpus = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGpuInstanceGetActiveVgpus);

                /* "cuda/bindings/_internal/_nvml.pyx":2332
 *         global __nvmlGpuInstanceGetActiveVgpus
 *         __nvmlGpuInstanceGetActiveVgpus = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetActiveVgpus')
 *         if __nvmlGpuInstanceGetActiveVgpus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetActiveVgpus == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2333
 *         __nvmlGpuInstanceGetActiveVgpus = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetActiveVgpus')
 *         if __nvmlGpuInstanceGetActiveVgpus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetActiveVgpus = dlsym(handle, 'nvmlGpuInstanceGetActiveVgpus')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2334
 *         if __nvmlGpuInstanceGetActiveVgpus == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGpuInstanceGetActiveVgpus = dlsym(handle, 'nvmlGpuInstanceGetActiveVgpus')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2334, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2333
 *         __nvmlGpuInstanceGetActiveVgpus = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetActiveVgpus')
 *         if __nvmlGpuInstanceGetActiveVgpus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetActiveVgpus = dlsym(handle, 'nvmlGpuInstanceGetActiveVgpus')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2335
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetActiveVgpus = dlsym(handle, 'nvmlGpuInstanceGetActiveVgpus')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGpuInstanceSetVgpuSchedulerState
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetActiveVgpus = dlsym(__pyx_v_handle, __pyx_k_nvmlGpuInstanceGetActiveVgpus);

                  /* "cuda/bindings/_internal/_nvml.pyx":2332
 *         global __nvmlGpuInstanceGetActiveVgpus
 *         __nvmlGpuInstanceGetActiveVgpus = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetActiveVgpus')
 *         if __nvmlGpuInstanceGetActiveVgpus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2338
 * 
 *         global __nvmlGpuInstanceSetVgpuSchedulerState
 *         __nvmlGpuInstanceSetVgpuSchedulerState = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceSetVgpuSchedulerState')             # <<<<<<<<<<<<<<
 *         if __nvmlGpuInstanceSetVgpuSchedulerState == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceSetVgpuSchedulerState = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGpuInstanceSetVgpuSchedulerS);

                /* "cuda/bindings/_internal/_nvml.pyx":2339
 *         global __nvmlGpuInstanceSetVgpuSchedulerState
 *         __nvmlGpuInstanceSetVgpuSchedulerState = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceSetVgpuSchedulerState')
 *         if __nvmlGpuInstanceSetVgpuSchedulerState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceSetVgpuSchedulerState == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2340
 *         __nvmlGpuInstanceSetVgpuSchedulerState = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceSetVgpuSchedulerState')
 *         if __nvmlGpuInstanceSetVgpuSchedulerState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceSetVgpuSchedulerState = dlsym(handle, 'nvmlGpuInstanceSetVgpuSchedulerState')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2341
 *         if __nvmlGpuInstanceSetVgpuSchedulerState == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGpuInstanceSetVgpuSchedulerState = dlsym(handle, 'nvmlGpuInstanceSetVgpuSchedulerState')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2341, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2340
 *         __nvmlGpuInstanceSetVgpuSchedulerState = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceSetVgpuSchedulerState')
 *         if __nvmlGpuInstanceSetVgpuSchedulerState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceSetVgpuSchedulerState = dlsym(handle, 'nvmlGpuInstanceSetVgpuSchedulerState')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2342
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGpuInstanceSetVgpuSchedulerState = dlsym(handle, 'nvmlGpuInstanceSetVgpuSchedulerState')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGpuInstanceGetVgpuSchedulerState
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceSetVgpuSchedulerState = dlsym(__pyx_v_handle, __pyx_k_nvmlGpuInstanceSetVgpuSchedulerS);

                  /* "cuda/bindings/_internal/_nvml.pyx":2339
 *         global __nvmlGpuInstanceSetVgpuSchedulerState
 *         __nvmlGpuInstanceSetVgpuSchedulerState = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceSetVgpuSchedulerState')
 *         if __nvmlGpuInstanceSetVgpuSchedulerState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2345
 * 
 *         global __nvmlGpuInstanceGetVgpuSchedulerState
 *         __nvmlGpuInstanceGetVgpuSchedulerState = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuSchedulerState')             # <<<<<<<<<<<<<<
 *         if __nvmlGpuInstanceGetVgpuSchedulerState == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuSchedulerState = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGpuInstanceGetVgpuSchedulerS);

                /* "cuda/bindings/_internal/_nvml.pyx":2346
 *         global __nvmlGpuInstanceGetVgpuSchedulerState
 *         __nvmlGpuInstanceGetVgpuSchedulerState = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuSchedulerState')
 *         if __nvmlGpuInstanceGetVgpuSchedulerState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuSchedulerState == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2347
 *         __nvmlGpuInstanceGetVgpuSchedulerState = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuSchedulerState')
 *         if __nvmlGpuInstanceGetVgpuSchedulerState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetVgpuSchedulerState = dlsym(handle, 'nvmlGpuInstanceGetVgpuSchedulerState')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2348
 *         if __nvmlGpuInstanceGetVgpuSchedulerState == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGpuInstanceGetVgpuSchedulerState = dlsym(handle, 'nvmlGpuInstanceGetVgpuSchedulerState')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2348, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2347
 *         __nvmlGpuInstanceGetVgpuSchedulerState = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuSchedulerState')
 *         if __nvmlGpuInstanceGetVgpuSchedulerState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetVgpuSchedulerState = dlsym(handle, 'nvmlGpuInstanceGetVgpuSchedulerState')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2349
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetVgpuSchedulerState = dlsym(handle, 'nvmlGpuInstanceGetVgpuSchedulerState')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGpuInstanceGetVgpuSchedulerLog
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuSchedulerState = dlsym(__pyx_v_handle, __pyx_k_nvmlGpuInstanceGetVgpuSchedulerS);

                  /* "cuda/bindings/_internal/_nvml.pyx":2346
 *         global __nvmlGpuInstanceGetVgpuSchedulerState
 *         __nvmlGpuInstanceGetVgpuSchedulerState = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuSchedulerState')
 *         if __nvmlGpuInstanceGetVgpuSchedulerState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2352
 * 
 *         global __nvmlGpuInstanceGetVgpuSchedulerLog
 *         __nvmlGpuInstanceGetVgpuSchedulerLog = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuSchedulerLog')             # <<<<<<<<<<<<<<
 *         if __nvmlGpuInstanceGetVgpuSchedulerLog == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuSchedulerLog = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGpuInstanceGetVgpuSchedulerL);

                /* "cuda/bindings/_internal/_nvml.pyx":2353
 *         global __nvmlGpuInstanceGetVgpuSchedulerLog
 *         __nvmlGpuInstanceGetVgpuSchedulerLog = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuSchedulerLog')
 *         if __nvmlGpuInstanceGetVgpuSchedulerLog == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuSchedulerLog == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2354
 *         __nvmlGpuInstanceGetVgpuSchedulerLog = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuSchedulerLog')
 *         if __nvmlGpuInstanceGetVgpuSchedulerLog == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetVgpuSchedulerLog = dlsym(handle, 'nvmlGpuInstanceGetVgpuSchedulerLog')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2355
 *         if __nvmlGpuInstanceGetVgpuSchedulerLog == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGpuInstanceGetVgpuSchedulerLog = dlsym(handle, 'nvmlGpuInstanceGetVgpuSchedulerLog')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2355, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2354
 *         __nvmlGpuInstanceGetVgpuSchedulerLog = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuSchedulerLog')
 *         if __nvmlGpuInstanceGetVgpuSchedulerLog == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetVgpuSchedulerLog = dlsym(handle, 'nvmlGpuInstanceGetVgpuSchedulerLog')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2356
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetVgpuSchedulerLog = dlsym(handle, 'nvmlGpuInstanceGetVgpuSchedulerLog')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGpuInstanceGetVgpuTypeCreatablePlacements
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuSchedulerLog = dlsym(__pyx_v_handle, __pyx_k_nvmlGpuInstanceGetVgpuSchedulerL);

                  /* "cuda/bindings/_internal/_nvml.pyx":2353
 *         global __nvmlGpuInstanceGetVgpuSchedulerLog
 *         __nvmlGpuInstanceGetVgpuSchedulerLog = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuSchedulerLog')
 *         if __nvmlGpuInstanceGetVgpuSchedulerLog == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2359
 * 
 *         global __nvmlGpuInstanceGetVgpuTypeCreatablePlacements
 *         __nvmlGpuInstanceGetVgpuTypeCreatablePlacements = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuTypeCreatablePlacements')             # <<<<<<<<<<<<<<
 *         if __nvmlGpuInstanceGetVgpuTypeCreatablePlacements == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuTypeCreatablePlacements = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGpuInstanceGetVgpuTypeCreata);

                /* "cuda/bindings/_internal/_nvml.pyx":2360
 *         global __nvmlGpuInstanceGetVgpuTypeCreatablePlacements
 *         __nvmlGpuInstanceGetVgpuTypeCreatablePlacements = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuTypeCreatablePlacements')
 *         if __nvmlGpuInstanceGetVgpuTypeCreatablePlacements == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuTypeCreatablePlacements == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2361
 *         __nvmlGpuInstanceGetVgpuTypeCreatablePlacements = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuTypeCreatablePlacements')
 *         if __nvmlGpuInstanceGetVgpuTypeCreatablePlacements == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetVgpuTypeCreatablePlacements = dlsym(handle, 'nvmlGpuInstanceGetVgpuTypeCreatablePlacements')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2362
 *         if __nvmlGpuInstanceGetVgpuTypeCreatablePlacements == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGpuInstanceGetVgpuTypeCreatablePlacements = dlsym(handle, 'nvmlGpuInstanceGetVgpuTypeCreatablePlacements')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2362, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2361
 *         __nvmlGpuInstanceGetVgpuTypeCreatablePlacements = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuTypeCreatablePlacements')
 *         if __nvmlGpuInstanceGetVgpuTypeCreatablePlacements == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetVgpuTypeCreatablePlacements = dlsym(handle, 'nvmlGpuInstanceGetVgpuTypeCreatablePlacements')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2363
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetVgpuTypeCreatablePlacements = dlsym(handle, 'nvmlGpuInstanceGetVgpuTypeCreatablePlacements')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGpuInstanceGetVgpuHeterogeneousMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuTypeCreatablePlacements = dlsym(__pyx_v_handle, __pyx_k_nvmlGpuInstanceGetVgpuTypeCreata);

                  /* "cuda/bindings/_internal/_nvml.pyx":2360
 *         global __nvmlGpuInstanceGetVgpuTypeCreatablePlacements
 *         __nvmlGpuInstanceGetVgpuTypeCreatablePlacements = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuTypeCreatablePlacements')
 *         if __nvmlGpuInstanceGetVgpuTypeCreatablePlacements == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2366
 * 
 *         global __nvmlGpuInstanceGetVgpuHeterogeneousMode
 *         __nvmlGpuInstanceGetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuHeterogeneousMode')             # <<<<<<<<<<<<<<
 *         if __nvmlGpuInstanceGetVgpuHeterogeneousMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGpuInstanceGetVgpuHeterogene);

                /* "cuda/bindings/_internal/_nvml.pyx":2367
 *         global __nvmlGpuInstanceGetVgpuHeterogeneousMode
 *         __nvmlGpuInstanceGetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuHeterogeneousMode')
 *         if __nvmlGpuInstanceGetVgpuHeterogeneousMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuHeterogeneousMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2368
 *         __nvmlGpuInstanceGetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuHeterogeneousMode')
 *         if __nvmlGpuInstanceGetVgpuHeterogeneousMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetVgpuHeterogeneousMode = dlsym(handle, 'nvmlGpuInstanceGetVgpuHeterogeneousMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2369
 *         if __nvmlGpuInstanceGetVgpuHeterogeneousMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGpuInstanceGetVgpuHeterogeneousMode = dlsym(handle, 'nvmlGpuInstanceGetVgpuHeterogeneousMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2369, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2368
 *         __nvmlGpuInstanceGetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuHeterogeneousMode')
 *         if __nvmlGpuInstanceGetVgpuHeterogeneousMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetVgpuHeterogeneousMode = dlsym(handle, 'nvmlGpuInstanceGetVgpuHeterogeneousMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2370
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetVgpuHeterogeneousMode = dlsym(handle, 'nvmlGpuInstanceGetVgpuHeterogeneousMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGpuInstanceSetVgpuHeterogeneousMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuHeterogeneousMode = dlsym(__pyx_v_handle, __pyx_k_nvmlGpuInstanceGetVgpuHeterogene);

                  /* "cuda/bindings/_internal/_nvml.pyx":2367
 *         global __nvmlGpuInstanceGetVgpuHeterogeneousMode
 *         __nvmlGpuInstanceGetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetVgpuHeterogeneousMode')
 *         if __nvmlGpuInstanceGetVgpuHeterogeneousMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2373
 * 
 *         global __nvmlGpuInstanceSetVgpuHeterogeneousMode
 *         __nvmlGpuInstanceSetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceSetVgpuHeterogeneousMode')             # <<<<<<<<<<<<<<
 *         if __nvmlGpuInstanceSetVgpuHeterogeneousMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceSetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGpuInstanceSetVgpuHeterogene);

                /* "cuda/bindings/_internal/_nvml.pyx":2374
 *         global __nvmlGpuInstanceSetVgpuHeterogeneousMode
 *         __nvmlGpuInstanceSetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceSetVgpuHeterogeneousMode')
 *         if __nvmlGpuInstanceSetVgpuHeterogeneousMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceSetVgpuHeterogeneousMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2375
 *         __nvmlGpuInstanceSetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceSetVgpuHeterogeneousMode')
 *         if __nvmlGpuInstanceSetVgpuHeterogeneousMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceSetVgpuHeterogeneousMode = dlsym(handle, 'nvmlGpuInstanceSetVgpuHeterogeneousMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2376
 *         if __nvmlGpuInstanceSetVgpuHeterogeneousMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGpuInstanceSetVgpuHeterogeneousMode = dlsym(handle, 'nvmlGpuInstanceSetVgpuHeterogeneousMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2376, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2375
 *         __nvmlGpuInstanceSetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceSetVgpuHeterogeneousMode')
 *         if __nvmlGpuInstanceSetVgpuHeterogeneousMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceSetVgpuHeterogeneousMode = dlsym(handle, 'nvmlGpuInstanceSetVgpuHeterogeneousMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2377
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGpuInstanceSetVgpuHeterogeneousMode = dlsym(handle, 'nvmlGpuInstanceSetVgpuHeterogeneousMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceGetMetadata
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceSetVgpuHeterogeneousMode = dlsym(__pyx_v_handle, __pyx_k_nvmlGpuInstanceSetVgpuHeterogene);

                  /* "cuda/bindings/_internal/_nvml.pyx":2374
 *         global __nvmlGpuInstanceSetVgpuHeterogeneousMode
 *         __nvmlGpuInstanceSetVgpuHeterogeneousMode = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceSetVgpuHeterogeneousMode')
 *         if __nvmlGpuInstanceSetVgpuHeterogeneousMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2380
 * 
 *         global __nvmlVgpuInstanceGetMetadata
 *         __nvmlVgpuInstanceGetMetadata = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetMetadata')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceGetMetadata == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetMetadata = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceGetMetadata);

                /* "cuda/bindings/_internal/_nvml.pyx":2381
 *         global __nvmlVgpuInstanceGetMetadata
 *         __nvmlVgpuInstanceGetMetadata = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetMetadata')
 *         if __nvmlVgpuInstanceGetMetadata == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetMetadata == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2382
 *         __nvmlVgpuInstanceGetMetadata = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetMetadata')
 *         if __nvmlVgpuInstanceGetMetadata == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetMetadata = dlsym(handle, 'nvmlVgpuInstanceGetMetadata')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2383
 *         if __nvmlVgpuInstanceGetMetadata == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceGetMetadata = dlsym(handle, 'nvmlVgpuInstanceGetMetadata')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2383, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2382
 *         __nvmlVgpuInstanceGetMetadata = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetMetadata')
 *         if __nvmlVgpuInstanceGetMetadata == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetMetadata = dlsym(handle, 'nvmlVgpuInstanceGetMetadata')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2384
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetMetadata = dlsym(handle, 'nvmlVgpuInstanceGetMetadata')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetVgpuMetadata
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetMetadata = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceGetMetadata);

                  /* "cuda/bindings/_internal/_nvml.pyx":2381
 *         global __nvmlVgpuInstanceGetMetadata
 *         __nvmlVgpuInstanceGetMetadata = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetMetadata')
 *         if __nvmlVgpuInstanceGetMetadata == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2387
 * 
 *         global __nvmlDeviceGetVgpuMetadata
 *         __nvmlDeviceGetVgpuMetadata = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuMetadata')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetVgpuMetadata == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuMetadata = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetVgpuMetadata);

                /* "cuda/bindings/_internal/_nvml.pyx":2388
 *         global __nvmlDeviceGetVgpuMetadata
 *         __nvmlDeviceGetVgpuMetadata = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuMetadata')
 *         if __nvmlDeviceGetVgpuMetadata == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuMetadata == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2389
 *         __nvmlDeviceGetVgpuMetadata = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuMetadata')
 *         if __nvmlDeviceGetVgpuMetadata == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuMetadata = dlsym(handle, 'nvmlDeviceGetVgpuMetadata')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2390
 *         if __nvmlDeviceGetVgpuMetadata == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetVgpuMetadata = dlsym(handle, 'nvmlDeviceGetVgpuMetadata')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2390, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2389
 *         __nvmlDeviceGetVgpuMetadata = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuMetadata')
 *         if __nvmlDeviceGetVgpuMetadata == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuMetadata = dlsym(handle, 'nvmlDeviceGetVgpuMetadata')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2391
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuMetadata = dlsym(handle, 'nvmlDeviceGetVgpuMetadata')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGetVgpuCompatibility
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuMetadata = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetVgpuMetadata);

                  /* "cuda/bindings/_internal/_nvml.pyx":2388
 *         global __nvmlDeviceGetVgpuMetadata
 *         __nvmlDeviceGetVgpuMetadata = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuMetadata')
 *         if __nvmlDeviceGetVgpuMetadata == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2394
 * 
 *         global __nvmlGetVgpuCompatibility
 *         __nvmlGetVgpuCompatibility = dlsym(RTLD_DEFAULT, 'nvmlGetVgpuCompatibility')             # <<<<<<<<<<<<<<
 *         if __nvmlGetVgpuCompatibility == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetVgpuCompatibility = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGetVgpuCompatibility);

                /* "cuda/bindings/_internal/_nvml.pyx":2395
 *         global __nvmlGetVgpuCompatibility
 *         __nvmlGetVgpuCompatibility = dlsym(RTLD_DEFAULT, 'nvmlGetVgpuCompatibility')
 *         if __nvmlGetVgpuCompatibility == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetVgpuCompatibility == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2396
 *         __nvmlGetVgpuCompatibility = dlsym(RTLD_DEFAULT, 'nvmlGetVgpuCompatibility')
 *         if __nvmlGetVgpuCompatibility == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGetVgpuCompatibility = dlsym(handle, 'nvmlGetVgpuCompatibility')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2397
 *         if __nvmlGetVgpuCompatibility == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGetVgpuCompatibility = dlsym(handle, 'nvmlGetVgpuCompatibility')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2397, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2396
 *         __nvmlGetVgpuCompatibility = dlsym(RTLD_DEFAULT, 'nvmlGetVgpuCompatibility')
 *         if __nvmlGetVgpuCompatibility == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGetVgpuCompatibility = dlsym(handle, 'nvmlGetVgpuCompatibility')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2398
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGetVgpuCompatibility = dlsym(handle, 'nvmlGetVgpuCompatibility')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetPgpuMetadataString
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetVgpuCompatibility = dlsym(__pyx_v_handle, __pyx_k_nvmlGetVgpuCompatibility);

                  /* "cuda/bindings/_internal/_nvml.pyx":2395
 *         global __nvmlGetVgpuCompatibility
 *         __nvmlGetVgpuCompatibility = dlsym(RTLD_DEFAULT, 'nvmlGetVgpuCompatibility')
 *         if __nvmlGetVgpuCompatibility == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2401
 * 
 *         global __nvmlDeviceGetPgpuMetadataString
 *         __nvmlDeviceGetPgpuMetadataString = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPgpuMetadataString')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetPgpuMetadataString == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPgpuMetadataString = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetPgpuMetadataString);

                /* "cuda/bindings/_internal/_nvml.pyx":2402
 *         global __nvmlDeviceGetPgpuMetadataString
 *         __nvmlDeviceGetPgpuMetadataString = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPgpuMetadataString')
 *         if __nvmlDeviceGetPgpuMetadataString == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPgpuMetadataString == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2403
 *         __nvmlDeviceGetPgpuMetadataString = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPgpuMetadataString')
 *         if __nvmlDeviceGetPgpuMetadataString == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPgpuMetadataString = dlsym(handle, 'nvmlDeviceGetPgpuMetadataString')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2404
 *         if __nvmlDeviceGetPgpuMetadataString == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetPgpuMetadataString = dlsym(handle, 'nvmlDeviceGetPgpuMetadataString')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2404, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2403
 *         __nvmlDeviceGetPgpuMetadataString = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPgpuMetadataString')
 *         if __nvmlDeviceGetPgpuMetadataString == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPgpuMetadataString = dlsym(handle, 'nvmlDeviceGetPgpuMetadataString')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2405
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetPgpuMetadataString = dlsym(handle, 'nvmlDeviceGetPgpuMetadataString')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetVgpuSchedulerLog
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPgpuMetadataString = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetPgpuMetadataString);

                  /* "cuda/bindings/_internal/_nvml.pyx":2402
 *         global __nvmlDeviceGetPgpuMetadataString
 *         __nvmlDeviceGetPgpuMetadataString = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPgpuMetadataString')
 *         if __nvmlDeviceGetPgpuMetadataString == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2408
 * 
 *         global __nvmlDeviceGetVgpuSchedulerLog
 *         __nvmlDeviceGetVgpuSchedulerLog = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerLog')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetVgpuSchedulerLog == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuSchedulerLog = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetVgpuSchedulerLog);

                /* "cuda/bindings/_internal/_nvml.pyx":2409
 *         global __nvmlDeviceGetVgpuSchedulerLog
 *         __nvmlDeviceGetVgpuSchedulerLog = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerLog')
 *         if __nvmlDeviceGetVgpuSchedulerLog == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuSchedulerLog == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2410
 *         __nvmlDeviceGetVgpuSchedulerLog = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerLog')
 *         if __nvmlDeviceGetVgpuSchedulerLog == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuSchedulerLog = dlsym(handle, 'nvmlDeviceGetVgpuSchedulerLog')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2411
 *         if __nvmlDeviceGetVgpuSchedulerLog == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetVgpuSchedulerLog = dlsym(handle, 'nvmlDeviceGetVgpuSchedulerLog')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2411, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2410
 *         __nvmlDeviceGetVgpuSchedulerLog = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerLog')
 *         if __nvmlDeviceGetVgpuSchedulerLog == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuSchedulerLog = dlsym(handle, 'nvmlDeviceGetVgpuSchedulerLog')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2412
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuSchedulerLog = dlsym(handle, 'nvmlDeviceGetVgpuSchedulerLog')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetVgpuSchedulerState
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuSchedulerLog = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetVgpuSchedulerLog);

                  /* "cuda/bindings/_internal/_nvml.pyx":2409
 *         global __nvmlDeviceGetVgpuSchedulerLog
 *         __nvmlDeviceGetVgpuSchedulerLog = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerLog')
 *         if __nvmlDeviceGetVgpuSchedulerLog == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2415
 * 
 *         global __nvmlDeviceGetVgpuSchedulerState
 *         __nvmlDeviceGetVgpuSchedulerState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerState')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetVgpuSchedulerState == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuSchedulerState = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetVgpuSchedulerState);

                /* "cuda/bindings/_internal/_nvml.pyx":2416
 *         global __nvmlDeviceGetVgpuSchedulerState
 *         __nvmlDeviceGetVgpuSchedulerState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerState')
 *         if __nvmlDeviceGetVgpuSchedulerState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuSchedulerState == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2417
 *         __nvmlDeviceGetVgpuSchedulerState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerState')
 *         if __nvmlDeviceGetVgpuSchedulerState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuSchedulerState = dlsym(handle, 'nvmlDeviceGetVgpuSchedulerState')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2418
 *         if __nvmlDeviceGetVgpuSchedulerState == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetVgpuSchedulerState = dlsym(handle, 'nvmlDeviceGetVgpuSchedulerState')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2418, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2417
 *         __nvmlDeviceGetVgpuSchedulerState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerState')
 *         if __nvmlDeviceGetVgpuSchedulerState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuSchedulerState = dlsym(handle, 'nvmlDeviceGetVgpuSchedulerState')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2419
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuSchedulerState = dlsym(handle, 'nvmlDeviceGetVgpuSchedulerState')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetVgpuSchedulerCapabilities
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuSchedulerState = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetVgpuSchedulerState);

                  /* "cuda/bindings/_internal/_nvml.pyx":2416
 *         global __nvmlDeviceGetVgpuSchedulerState
 *         __nvmlDeviceGetVgpuSchedulerState = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerState')
 *         if __nvmlDeviceGetVgpuSchedulerState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2422
 * 
 *         global __nvmlDeviceGetVgpuSchedulerCapabilities
 *         __nvmlDeviceGetVgpuSchedulerCapabilities = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerCapabilities')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetVgpuSchedulerCapabilities == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuSchedulerCapabilities = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetVgpuSchedulerCapabi);

                /* "cuda/bindings/_internal/_nvml.pyx":2423
 *         global __nvmlDeviceGetVgpuSchedulerCapabilities
 *         __nvmlDeviceGetVgpuSchedulerCapabilities = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerCapabilities')
 *         if __nvmlDeviceGetVgpuSchedulerCapabilities == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuSchedulerCapabilities == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2424
 *         __nvmlDeviceGetVgpuSchedulerCapabilities = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerCapabilities')
 *         if __nvmlDeviceGetVgpuSchedulerCapabilities == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuSchedulerCapabilities = dlsym(handle, 'nvmlDeviceGetVgpuSchedulerCapabilities')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2425
 *         if __nvmlDeviceGetVgpuSchedulerCapabilities == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetVgpuSchedulerCapabilities = dlsym(handle, 'nvmlDeviceGetVgpuSchedulerCapabilities')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2425, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2424
 *         __nvmlDeviceGetVgpuSchedulerCapabilities = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerCapabilities')
 *         if __nvmlDeviceGetVgpuSchedulerCapabilities == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuSchedulerCapabilities = dlsym(handle, 'nvmlDeviceGetVgpuSchedulerCapabilities')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2426
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuSchedulerCapabilities = dlsym(handle, 'nvmlDeviceGetVgpuSchedulerCapabilities')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetVgpuSchedulerState
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuSchedulerCapabilities = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetVgpuSchedulerCapabi);

                  /* "cuda/bindings/_internal/_nvml.pyx":2423
 *         global __nvmlDeviceGetVgpuSchedulerCapabilities
 *         __nvmlDeviceGetVgpuSchedulerCapabilities = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuSchedulerCapabilities')
 *         if __nvmlDeviceGetVgpuSchedulerCapabilities == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2429
 * 
 *         global __nvmlDeviceSetVgpuSchedulerState
 *         __nvmlDeviceSetVgpuSchedulerState = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVgpuSchedulerState')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetVgpuSchedulerState == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVgpuSchedulerState = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetVgpuSchedulerState);

                /* "cuda/bindings/_internal/_nvml.pyx":2430
 *         global __nvmlDeviceSetVgpuSchedulerState
 *         __nvmlDeviceSetVgpuSchedulerState = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVgpuSchedulerState')
 *         if __nvmlDeviceSetVgpuSchedulerState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVgpuSchedulerState == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2431
 *         __nvmlDeviceSetVgpuSchedulerState = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVgpuSchedulerState')
 *         if __nvmlDeviceSetVgpuSchedulerState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetVgpuSchedulerState = dlsym(handle, 'nvmlDeviceSetVgpuSchedulerState')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2432
 *         if __nvmlDeviceSetVgpuSchedulerState == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetVgpuSchedulerState = dlsym(handle, 'nvmlDeviceSetVgpuSchedulerState')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2432, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2431
 *         __nvmlDeviceSetVgpuSchedulerState = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVgpuSchedulerState')
 *         if __nvmlDeviceSetVgpuSchedulerState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetVgpuSchedulerState = dlsym(handle, 'nvmlDeviceSetVgpuSchedulerState')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2433
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetVgpuSchedulerState = dlsym(handle, 'nvmlDeviceSetVgpuSchedulerState')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGetVgpuVersion
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVgpuSchedulerState = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetVgpuSchedulerState);

                  /* "cuda/bindings/_internal/_nvml.pyx":2430
 *         global __nvmlDeviceSetVgpuSchedulerState
 *         __nvmlDeviceSetVgpuSchedulerState = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetVgpuSchedulerState')
 *         if __nvmlDeviceSetVgpuSchedulerState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2436
 * 
 *         global __nvmlGetVgpuVersion
 *         __nvmlGetVgpuVersion = dlsym(RTLD_DEFAULT, 'nvmlGetVgpuVersion')             # <<<<<<<<<<<<<<
 *         if __nvmlGetVgpuVersion == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetVgpuVersion = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGetVgpuVersion);

                /* "cuda/bindings/_internal/_nvml.pyx":2437
 *         global __nvmlGetVgpuVersion
 *         __nvmlGetVgpuVersion = dlsym(RTLD_DEFAULT, 'nvmlGetVgpuVersion')
 *         if __nvmlGetVgpuVersion == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetVgpuVersion == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2438
 *         __nvmlGetVgpuVersion = dlsym(RTLD_DEFAULT, 'nvmlGetVgpuVersion')
 *         if __nvmlGetVgpuVersion == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGetVgpuVersion = dlsym(handle, 'nvmlGetVgpuVersion')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2439
 *         if __nvmlGetVgpuVersion == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGetVgpuVersion = dlsym(handle, 'nvmlGetVgpuVersion')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2439, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2438
 *         __nvmlGetVgpuVersion = dlsym(RTLD_DEFAULT, 'nvmlGetVgpuVersion')
 *         if __nvmlGetVgpuVersion == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGetVgpuVersion = dlsym(handle, 'nvmlGetVgpuVersion')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2440
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGetVgpuVersion = dlsym(handle, 'nvmlGetVgpuVersion')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlSetVgpuVersion
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetVgpuVersion = dlsym(__pyx_v_handle, __pyx_k_nvmlGetVgpuVersion);

                  /* "cuda/bindings/_internal/_nvml.pyx":2437
 *         global __nvmlGetVgpuVersion
 *         __nvmlGetVgpuVersion = dlsym(RTLD_DEFAULT, 'nvmlGetVgpuVersion')
 *         if __nvmlGetVgpuVersion == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2443
 * 
 *         global __nvmlSetVgpuVersion
 *         __nvmlSetVgpuVersion = dlsym(RTLD_DEFAULT, 'nvmlSetVgpuVersion')             # <<<<<<<<<<<<<<
 *         if __nvmlSetVgpuVersion == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSetVgpuVersion = dlsym(RTLD_DEFAULT, __pyx_k_nvmlSetVgpuVersion);

                /* "cuda/bindings/_internal/_nvml.pyx":2444
 *         global __nvmlSetVgpuVersion
 *         __nvmlSetVgpuVersion = dlsym(RTLD_DEFAULT, 'nvmlSetVgpuVersion')
 *         if __nvmlSetVgpuVersion == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSetVgpuVersion == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2445
 *         __nvmlSetVgpuVersion = dlsym(RTLD_DEFAULT, 'nvmlSetVgpuVersion')
 *         if __nvmlSetVgpuVersion == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSetVgpuVersion = dlsym(handle, 'nvmlSetVgpuVersion')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2446
 *         if __nvmlSetVgpuVersion == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlSetVgpuVersion = dlsym(handle, 'nvmlSetVgpuVersion')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2446, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2445
 *         __nvmlSetVgpuVersion = dlsym(RTLD_DEFAULT, 'nvmlSetVgpuVersion')
 *         if __nvmlSetVgpuVersion == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlSetVgpuVersion = dlsym(handle, 'nvmlSetVgpuVersion')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2447
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlSetVgpuVersion = dlsym(handle, 'nvmlSetVgpuVersion')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetVgpuUtilization
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSetVgpuVersion = dlsym(__pyx_v_handle, __pyx_k_nvmlSetVgpuVersion);

                  /* "cuda/bindings/_internal/_nvml.pyx":2444
 *         global __nvmlSetVgpuVersion
 *         __nvmlSetVgpuVersion = dlsym(RTLD_DEFAULT, 'nvmlSetVgpuVersion')
 *         if __nvmlSetVgpuVersion == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2450
 * 
 *         global __nvmlDeviceGetVgpuUtilization
 *         __nvmlDeviceGetVgpuUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuUtilization')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetVgpuUtilization == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuUtilization = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetVgpuUtilization);

                /* "cuda/bindings/_internal/_nvml.pyx":2451
 *         global __nvmlDeviceGetVgpuUtilization
 *         __nvmlDeviceGetVgpuUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuUtilization')
 *         if __nvmlDeviceGetVgpuUtilization == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuUtilization == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2452
 *         __nvmlDeviceGetVgpuUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuUtilization')
 *         if __nvmlDeviceGetVgpuUtilization == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuUtilization = dlsym(handle, 'nvmlDeviceGetVgpuUtilization')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2453
 *         if __nvmlDeviceGetVgpuUtilization == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetVgpuUtilization = dlsym(handle, 'nvmlDeviceGetVgpuUtilization')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2453, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2452
 *         __nvmlDeviceGetVgpuUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuUtilization')
 *         if __nvmlDeviceGetVgpuUtilization == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuUtilization = dlsym(handle, 'nvmlDeviceGetVgpuUtilization')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2454
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuUtilization = dlsym(handle, 'nvmlDeviceGetVgpuUtilization')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetVgpuInstancesUtilizationInfo
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuUtilization = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetVgpuUtilization);

                  /* "cuda/bindings/_internal/_nvml.pyx":2451
 *         global __nvmlDeviceGetVgpuUtilization
 *         __nvmlDeviceGetVgpuUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuUtilization')
 *         if __nvmlDeviceGetVgpuUtilization == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2457
 * 
 *         global __nvmlDeviceGetVgpuInstancesUtilizationInfo
 *         __nvmlDeviceGetVgpuInstancesUtilizationInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuInstancesUtilizationInfo')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetVgpuInstancesUtilizationInfo == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuInstancesUtilizationInfo = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetVgpuInstancesUtiliz);

                /* "cuda/bindings/_internal/_nvml.pyx":2458
 *         global __nvmlDeviceGetVgpuInstancesUtilizationInfo
 *         __nvmlDeviceGetVgpuInstancesUtilizationInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuInstancesUtilizationInfo')
 *         if __nvmlDeviceGetVgpuInstancesUtilizationInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuInstancesUtilizationInfo == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2459
 *         __nvmlDeviceGetVgpuInstancesUtilizationInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuInstancesUtilizationInfo')
 *         if __nvmlDeviceGetVgpuInstancesUtilizationInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuInstancesUtilizationInfo = dlsym(handle, 'nvmlDeviceGetVgpuInstancesUtilizationInfo')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2460
 *         if __nvmlDeviceGetVgpuInstancesUtilizationInfo == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetVgpuInstancesUtilizationInfo = dlsym(handle, 'nvmlDeviceGetVgpuInstancesUtilizationInfo')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2460, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2459
 *         __nvmlDeviceGetVgpuInstancesUtilizationInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuInstancesUtilizationInfo')
 *         if __nvmlDeviceGetVgpuInstancesUtilizationInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuInstancesUtilizationInfo = dlsym(handle, 'nvmlDeviceGetVgpuInstancesUtilizationInfo')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2461
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuInstancesUtilizationInfo = dlsym(handle, 'nvmlDeviceGetVgpuInstancesUtilizationInfo')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetVgpuProcessUtilization
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuInstancesUtilizationInfo = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetVgpuInstancesUtiliz);

                  /* "cuda/bindings/_internal/_nvml.pyx":2458
 *         global __nvmlDeviceGetVgpuInstancesUtilizationInfo
 *         __nvmlDeviceGetVgpuInstancesUtilizationInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuInstancesUtilizationInfo')
 *         if __nvmlDeviceGetVgpuInstancesUtilizationInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2464
 * 
 *         global __nvmlDeviceGetVgpuProcessUtilization
 *         __nvmlDeviceGetVgpuProcessUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuProcessUtilization')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetVgpuProcessUtilization == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuProcessUtilization = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetVgpuProcessUtilizat);

                /* "cuda/bindings/_internal/_nvml.pyx":2465
 *         global __nvmlDeviceGetVgpuProcessUtilization
 *         __nvmlDeviceGetVgpuProcessUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuProcessUtilization')
 *         if __nvmlDeviceGetVgpuProcessUtilization == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuProcessUtilization == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2466
 *         __nvmlDeviceGetVgpuProcessUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuProcessUtilization')
 *         if __nvmlDeviceGetVgpuProcessUtilization == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuProcessUtilization = dlsym(handle, 'nvmlDeviceGetVgpuProcessUtilization')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2467
 *         if __nvmlDeviceGetVgpuProcessUtilization == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetVgpuProcessUtilization = dlsym(handle, 'nvmlDeviceGetVgpuProcessUtilization')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2467, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2466
 *         __nvmlDeviceGetVgpuProcessUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuProcessUtilization')
 *         if __nvmlDeviceGetVgpuProcessUtilization == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuProcessUtilization = dlsym(handle, 'nvmlDeviceGetVgpuProcessUtilization')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2468
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuProcessUtilization = dlsym(handle, 'nvmlDeviceGetVgpuProcessUtilization')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetVgpuProcessesUtilizationInfo
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuProcessUtilization = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetVgpuProcessUtilizat);

                  /* "cuda/bindings/_internal/_nvml.pyx":2465
 *         global __nvmlDeviceGetVgpuProcessUtilization
 *         __nvmlDeviceGetVgpuProcessUtilization = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuProcessUtilization')
 *         if __nvmlDeviceGetVgpuProcessUtilization == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2471
 * 
 *         global __nvmlDeviceGetVgpuProcessesUtilizationInfo
 *         __nvmlDeviceGetVgpuProcessesUtilizationInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuProcessesUtilizationInfo')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetVgpuProcessesUtilizationInfo == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuProcessesUtilizationInfo = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetVgpuProcessesUtiliz);

                /* "cuda/bindings/_internal/_nvml.pyx":2472
 *         global __nvmlDeviceGetVgpuProcessesUtilizationInfo
 *         __nvmlDeviceGetVgpuProcessesUtilizationInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuProcessesUtilizationInfo')
 *         if __nvmlDeviceGetVgpuProcessesUtilizationInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuProcessesUtilizationInfo == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2473
 *         __nvmlDeviceGetVgpuProcessesUtilizationInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuProcessesUtilizationInfo')
 *         if __nvmlDeviceGetVgpuProcessesUtilizationInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuProcessesUtilizationInfo = dlsym(handle, 'nvmlDeviceGetVgpuProcessesUtilizationInfo')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2474
 *         if __nvmlDeviceGetVgpuProcessesUtilizationInfo == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetVgpuProcessesUtilizationInfo = dlsym(handle, 'nvmlDeviceGetVgpuProcessesUtilizationInfo')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2474, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2473
 *         __nvmlDeviceGetVgpuProcessesUtilizationInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuProcessesUtilizationInfo')
 *         if __nvmlDeviceGetVgpuProcessesUtilizationInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuProcessesUtilizationInfo = dlsym(handle, 'nvmlDeviceGetVgpuProcessesUtilizationInfo')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2475
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetVgpuProcessesUtilizationInfo = dlsym(handle, 'nvmlDeviceGetVgpuProcessesUtilizationInfo')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceGetAccountingMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuProcessesUtilizationInfo = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetVgpuProcessesUtiliz);

                  /* "cuda/bindings/_internal/_nvml.pyx":2472
 *         global __nvmlDeviceGetVgpuProcessesUtilizationInfo
 *         __nvmlDeviceGetVgpuProcessesUtilizationInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetVgpuProcessesUtilizationInfo')
 *         if __nvmlDeviceGetVgpuProcessesUtilizationInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2478
 * 
 *         global __nvmlVgpuInstanceGetAccountingMode
 *         __nvmlVgpuInstanceGetAccountingMode = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetAccountingMode')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceGetAccountingMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetAccountingMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceGetAccountingMod);

                /* "cuda/bindings/_internal/_nvml.pyx":2479
 *         global __nvmlVgpuInstanceGetAccountingMode
 *         __nvmlVgpuInstanceGetAccountingMode = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetAccountingMode')
 *         if __nvmlVgpuInstanceGetAccountingMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetAccountingMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2480
 *         __nvmlVgpuInstanceGetAccountingMode = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetAccountingMode')
 *         if __nvmlVgpuInstanceGetAccountingMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetAccountingMode = dlsym(handle, 'nvmlVgpuInstanceGetAccountingMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2481
 *         if __nvmlVgpuInstanceGetAccountingMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceGetAccountingMode = dlsym(handle, 'nvmlVgpuInstanceGetAccountingMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2481, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2480
 *         __nvmlVgpuInstanceGetAccountingMode = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetAccountingMode')
 *         if __nvmlVgpuInstanceGetAccountingMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetAccountingMode = dlsym(handle, 'nvmlVgpuInstanceGetAccountingMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2482
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetAccountingMode = dlsym(handle, 'nvmlVgpuInstanceGetAccountingMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceGetAccountingPids
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetAccountingMode = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceGetAccountingMod);

                  /* "cuda/bindings/_internal/_nvml.pyx":2479
 *         global __nvmlVgpuInstanceGetAccountingMode
 *         __nvmlVgpuInstanceGetAccountingMode = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetAccountingMode')
 *         if __nvmlVgpuInstanceGetAccountingMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2485
 * 
 *         global __nvmlVgpuInstanceGetAccountingPids
 *         __nvmlVgpuInstanceGetAccountingPids = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetAccountingPids')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceGetAccountingPids == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetAccountingPids = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceGetAccountingPid);

                /* "cuda/bindings/_internal/_nvml.pyx":2486
 *         global __nvmlVgpuInstanceGetAccountingPids
 *         __nvmlVgpuInstanceGetAccountingPids = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetAccountingPids')
 *         if __nvmlVgpuInstanceGetAccountingPids == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetAccountingPids == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2487
 *         __nvmlVgpuInstanceGetAccountingPids = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetAccountingPids')
 *         if __nvmlVgpuInstanceGetAccountingPids == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetAccountingPids = dlsym(handle, 'nvmlVgpuInstanceGetAccountingPids')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2488
 *         if __nvmlVgpuInstanceGetAccountingPids == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceGetAccountingPids = dlsym(handle, 'nvmlVgpuInstanceGetAccountingPids')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2488, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2487
 *         __nvmlVgpuInstanceGetAccountingPids = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetAccountingPids')
 *         if __nvmlVgpuInstanceGetAccountingPids == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetAccountingPids = dlsym(handle, 'nvmlVgpuInstanceGetAccountingPids')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2489
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetAccountingPids = dlsym(handle, 'nvmlVgpuInstanceGetAccountingPids')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceGetAccountingStats
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetAccountingPids = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceGetAccountingPid);

                  /* "cuda/bindings/_internal/_nvml.pyx":2486
 *         global __nvmlVgpuInstanceGetAccountingPids
 *         __nvmlVgpuInstanceGetAccountingPids = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetAccountingPids')
 *         if __nvmlVgpuInstanceGetAccountingPids == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2492
 * 
 *         global __nvmlVgpuInstanceGetAccountingStats
 *         __nvmlVgpuInstanceGetAccountingStats = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetAccountingStats')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceGetAccountingStats == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetAccountingStats = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceGetAccountingSta);

                /* "cuda/bindings/_internal/_nvml.pyx":2493
 *         global __nvmlVgpuInstanceGetAccountingStats
 *         __nvmlVgpuInstanceGetAccountingStats = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetAccountingStats')
 *         if __nvmlVgpuInstanceGetAccountingStats == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetAccountingStats == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2494
 *         __nvmlVgpuInstanceGetAccountingStats = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetAccountingStats')
 *         if __nvmlVgpuInstanceGetAccountingStats == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetAccountingStats = dlsym(handle, 'nvmlVgpuInstanceGetAccountingStats')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2495
 *         if __nvmlVgpuInstanceGetAccountingStats == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceGetAccountingStats = dlsym(handle, 'nvmlVgpuInstanceGetAccountingStats')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2495, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2494
 *         __nvmlVgpuInstanceGetAccountingStats = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetAccountingStats')
 *         if __nvmlVgpuInstanceGetAccountingStats == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetAccountingStats = dlsym(handle, 'nvmlVgpuInstanceGetAccountingStats')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2496
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetAccountingStats = dlsym(handle, 'nvmlVgpuInstanceGetAccountingStats')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceClearAccountingPids
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetAccountingStats = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceGetAccountingSta);

                  /* "cuda/bindings/_internal/_nvml.pyx":2493
 *         global __nvmlVgpuInstanceGetAccountingStats
 *         __nvmlVgpuInstanceGetAccountingStats = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetAccountingStats')
 *         if __nvmlVgpuInstanceGetAccountingStats == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2499
 * 
 *         global __nvmlVgpuInstanceClearAccountingPids
 *         __nvmlVgpuInstanceClearAccountingPids = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceClearAccountingPids')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceClearAccountingPids == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceClearAccountingPids = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceClearAccountingP);

                /* "cuda/bindings/_internal/_nvml.pyx":2500
 *         global __nvmlVgpuInstanceClearAccountingPids
 *         __nvmlVgpuInstanceClearAccountingPids = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceClearAccountingPids')
 *         if __nvmlVgpuInstanceClearAccountingPids == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceClearAccountingPids == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2501
 *         __nvmlVgpuInstanceClearAccountingPids = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceClearAccountingPids')
 *         if __nvmlVgpuInstanceClearAccountingPids == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceClearAccountingPids = dlsym(handle, 'nvmlVgpuInstanceClearAccountingPids')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2502
 *         if __nvmlVgpuInstanceClearAccountingPids == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceClearAccountingPids = dlsym(handle, 'nvmlVgpuInstanceClearAccountingPids')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2502, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2501
 *         __nvmlVgpuInstanceClearAccountingPids = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceClearAccountingPids')
 *         if __nvmlVgpuInstanceClearAccountingPids == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceClearAccountingPids = dlsym(handle, 'nvmlVgpuInstanceClearAccountingPids')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2503
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceClearAccountingPids = dlsym(handle, 'nvmlVgpuInstanceClearAccountingPids')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlVgpuInstanceGetLicenseInfo_v2
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceClearAccountingPids = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceClearAccountingP);

                  /* "cuda/bindings/_internal/_nvml.pyx":2500
 *         global __nvmlVgpuInstanceClearAccountingPids
 *         __nvmlVgpuInstanceClearAccountingPids = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceClearAccountingPids')
 *         if __nvmlVgpuInstanceClearAccountingPids == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2506
 * 
 *         global __nvmlVgpuInstanceGetLicenseInfo_v2
 *         __nvmlVgpuInstanceGetLicenseInfo_v2 = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetLicenseInfo_v2')             # <<<<<<<<<<<<<<
 *         if __nvmlVgpuInstanceGetLicenseInfo_v2 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetLicenseInfo_v2 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlVgpuInstanceGetLicenseInfo_v);

                /* "cuda/bindings/_internal/_nvml.pyx":2507
 *         global __nvmlVgpuInstanceGetLicenseInfo_v2
 *         __nvmlVgpuInstanceGetLicenseInfo_v2 = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetLicenseInfo_v2')
 *         if __nvmlVgpuInstanceGetLicenseInfo_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetLicenseInfo_v2 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2508
 *         __nvmlVgpuInstanceGetLicenseInfo_v2 = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetLicenseInfo_v2')
 *         if __nvmlVgpuInstanceGetLicenseInfo_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetLicenseInfo_v2 = dlsym(handle, 'nvmlVgpuInstanceGetLicenseInfo_v2')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2509
 *         if __nvmlVgpuInstanceGetLicenseInfo_v2 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlVgpuInstanceGetLicenseInfo_v2 = dlsym(handle, 'nvmlVgpuInstanceGetLicenseInfo_v2')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2509, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2508
 *         __nvmlVgpuInstanceGetLicenseInfo_v2 = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetLicenseInfo_v2')
 *         if __nvmlVgpuInstanceGetLicenseInfo_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetLicenseInfo_v2 = dlsym(handle, 'nvmlVgpuInstanceGetLicenseInfo_v2')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2510
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlVgpuInstanceGetLicenseInfo_v2 = dlsym(handle, 'nvmlVgpuInstanceGetLicenseInfo_v2')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGetExcludedDeviceCount
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetLicenseInfo_v2 = dlsym(__pyx_v_handle, __pyx_k_nvmlVgpuInstanceGetLicenseInfo_v);

                  /* "cuda/bindings/_internal/_nvml.pyx":2507
 *         global __nvmlVgpuInstanceGetLicenseInfo_v2
 *         __nvmlVgpuInstanceGetLicenseInfo_v2 = dlsym(RTLD_DEFAULT, 'nvmlVgpuInstanceGetLicenseInfo_v2')
 *         if __nvmlVgpuInstanceGetLicenseInfo_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2513
 * 
 *         global __nvmlGetExcludedDeviceCount
 *         __nvmlGetExcludedDeviceCount = dlsym(RTLD_DEFAULT, 'nvmlGetExcludedDeviceCount')             # <<<<<<<<<<<<<<
 *         if __nvmlGetExcludedDeviceCount == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetExcludedDeviceCount = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGetExcludedDeviceCount);

                /* "cuda/bindings/_internal/_nvml.pyx":2514
 *         global __nvmlGetExcludedDeviceCount
 *         __nvmlGetExcludedDeviceCount = dlsym(RTLD_DEFAULT, 'nvmlGetExcludedDeviceCount')
 *         if __nvmlGetExcludedDeviceCount == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetExcludedDeviceCount == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2515
 *         __nvmlGetExcludedDeviceCount = dlsym(RTLD_DEFAULT, 'nvmlGetExcludedDeviceCount')
 *         if __nvmlGetExcludedDeviceCount == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGetExcludedDeviceCount = dlsym(handle, 'nvmlGetExcludedDeviceCount')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2516
 *         if __nvmlGetExcludedDeviceCount == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGetExcludedDeviceCount = dlsym(handle, 'nvmlGetExcludedDeviceCount')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2516, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2515
 *         __nvmlGetExcludedDeviceCount = dlsym(RTLD_DEFAULT, 'nvmlGetExcludedDeviceCount')
 *         if __nvmlGetExcludedDeviceCount == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGetExcludedDeviceCount = dlsym(handle, 'nvmlGetExcludedDeviceCount')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2517
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGetExcludedDeviceCount = dlsym(handle, 'nvmlGetExcludedDeviceCount')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGetExcludedDeviceInfoByIndex
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetExcludedDeviceCount = dlsym(__pyx_v_handle, __pyx_k_nvmlGetExcludedDeviceCount);

                  /* "cuda/bindings/_internal/_nvml.pyx":2514
 *         global __nvmlGetExcludedDeviceCount
 *         __nvmlGetExcludedDeviceCount = dlsym(RTLD_DEFAULT, 'nvmlGetExcludedDeviceCount')
 *         if __nvmlGetExcludedDeviceCount == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2520
 * 
 *         global __nvmlGetExcludedDeviceInfoByIndex
 *         __nvmlGetExcludedDeviceInfoByIndex = dlsym(RTLD_DEFAULT, 'nvmlGetExcludedDeviceInfoByIndex')             # <<<<<<<<<<<<<<
 *         if __nvmlGetExcludedDeviceInfoByIndex == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetExcludedDeviceInfoByIndex = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGetExcludedDeviceInfoByIndex);

                /* "cuda/bindings/_internal/_nvml.pyx":2521
 *         global __nvmlGetExcludedDeviceInfoByIndex
 *         __nvmlGetExcludedDeviceInfoByIndex = dlsym(RTLD_DEFAULT, 'nvmlGetExcludedDeviceInfoByIndex')
 *         if __nvmlGetExcludedDeviceInfoByIndex == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetExcludedDeviceInfoByIndex == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2522
 *         __nvmlGetExcludedDeviceInfoByIndex = dlsym(RTLD_DEFAULT, 'nvmlGetExcludedDeviceInfoByIndex')
 *         if __nvmlGetExcludedDeviceInfoByIndex == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGetExcludedDeviceInfoByIndex = dlsym(handle, 'nvmlGetExcludedDeviceInfoByIndex')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2523
 *         if __nvmlGetExcludedDeviceInfoByIndex == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGetExcludedDeviceInfoByIndex = dlsym(handle, 'nvmlGetExcludedDeviceInfoByIndex')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2523, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2522
 *         __nvmlGetExcludedDeviceInfoByIndex = dlsym(RTLD_DEFAULT, 'nvmlGetExcludedDeviceInfoByIndex')
 *         if __nvmlGetExcludedDeviceInfoByIndex == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGetExcludedDeviceInfoByIndex = dlsym(handle, 'nvmlGetExcludedDeviceInfoByIndex')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2524
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGetExcludedDeviceInfoByIndex = dlsym(handle, 'nvmlGetExcludedDeviceInfoByIndex')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetMigMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetExcludedDeviceInfoByIndex = dlsym(__pyx_v_handle, __pyx_k_nvmlGetExcludedDeviceInfoByIndex);

                  /* "cuda/bindings/_internal/_nvml.pyx":2521
 *         global __nvmlGetExcludedDeviceInfoByIndex
 *         __nvmlGetExcludedDeviceInfoByIndex = dlsym(RTLD_DEFAULT, 'nvmlGetExcludedDeviceInfoByIndex')
 *         if __nvmlGetExcludedDeviceInfoByIndex == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2527
 * 
 *         global __nvmlDeviceSetMigMode
 *         __nvmlDeviceSetMigMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetMigMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetMigMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetMigMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetMigMode);

                /* "cuda/bindings/_internal/_nvml.pyx":2528
 *         global __nvmlDeviceSetMigMode
 *         __nvmlDeviceSetMigMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetMigMode')
 *         if __nvmlDeviceSetMigMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetMigMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2529
 *         __nvmlDeviceSetMigMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetMigMode')
 *         if __nvmlDeviceSetMigMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetMigMode = dlsym(handle, 'nvmlDeviceSetMigMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2530
 *         if __nvmlDeviceSetMigMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetMigMode = dlsym(handle, 'nvmlDeviceSetMigMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2530, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2529
 *         __nvmlDeviceSetMigMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetMigMode')
 *         if __nvmlDeviceSetMigMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetMigMode = dlsym(handle, 'nvmlDeviceSetMigMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2531
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetMigMode = dlsym(handle, 'nvmlDeviceSetMigMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetMigMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetMigMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetMigMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":2528
 *         global __nvmlDeviceSetMigMode
 *         __nvmlDeviceSetMigMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetMigMode')
 *         if __nvmlDeviceSetMigMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2534
 * 
 *         global __nvmlDeviceGetMigMode
 *         __nvmlDeviceGetMigMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMigMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetMigMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMigMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetMigMode);

                /* "cuda/bindings/_internal/_nvml.pyx":2535
 *         global __nvmlDeviceGetMigMode
 *         __nvmlDeviceGetMigMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMigMode')
 *         if __nvmlDeviceGetMigMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMigMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2536
 *         __nvmlDeviceGetMigMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMigMode')
 *         if __nvmlDeviceGetMigMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMigMode = dlsym(handle, 'nvmlDeviceGetMigMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2537
 *         if __nvmlDeviceGetMigMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetMigMode = dlsym(handle, 'nvmlDeviceGetMigMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2537, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2536
 *         __nvmlDeviceGetMigMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMigMode')
 *         if __nvmlDeviceGetMigMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMigMode = dlsym(handle, 'nvmlDeviceGetMigMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2538
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetMigMode = dlsym(handle, 'nvmlDeviceGetMigMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetGpuInstanceProfileInfoV
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMigMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetMigMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":2535
 *         global __nvmlDeviceGetMigMode
 *         __nvmlDeviceGetMigMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMigMode')
 *         if __nvmlDeviceGetMigMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2541
 * 
 *         global __nvmlDeviceGetGpuInstanceProfileInfoV
 *         __nvmlDeviceGetGpuInstanceProfileInfoV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceProfileInfoV')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetGpuInstanceProfileInfoV == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceProfileInfoV = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetGpuInstanceProfileI);

                /* "cuda/bindings/_internal/_nvml.pyx":2542
 *         global __nvmlDeviceGetGpuInstanceProfileInfoV
 *         __nvmlDeviceGetGpuInstanceProfileInfoV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceProfileInfoV')
 *         if __nvmlDeviceGetGpuInstanceProfileInfoV == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceProfileInfoV == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2543
 *         __nvmlDeviceGetGpuInstanceProfileInfoV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceProfileInfoV')
 *         if __nvmlDeviceGetGpuInstanceProfileInfoV == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuInstanceProfileInfoV = dlsym(handle, 'nvmlDeviceGetGpuInstanceProfileInfoV')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2544
 *         if __nvmlDeviceGetGpuInstanceProfileInfoV == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetGpuInstanceProfileInfoV = dlsym(handle, 'nvmlDeviceGetGpuInstanceProfileInfoV')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2544, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2543
 *         __nvmlDeviceGetGpuInstanceProfileInfoV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceProfileInfoV')
 *         if __nvmlDeviceGetGpuInstanceProfileInfoV == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuInstanceProfileInfoV = dlsym(handle, 'nvmlDeviceGetGpuInstanceProfileInfoV')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2545
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuInstanceProfileInfoV = dlsym(handle, 'nvmlDeviceGetGpuInstanceProfileInfoV')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetGpuInstancePossiblePlacements_v2
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceProfileInfoV = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetGpuInstanceProfileI);

                  /* "cuda/bindings/_internal/_nvml.pyx":2542
 *         global __nvmlDeviceGetGpuInstanceProfileInfoV
 *         __nvmlDeviceGetGpuInstanceProfileInfoV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceProfileInfoV')
 *         if __nvmlDeviceGetGpuInstanceProfileInfoV == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2548
 * 
 *         global __nvmlDeviceGetGpuInstancePossiblePlacements_v2
 *         __nvmlDeviceGetGpuInstancePossiblePlacements_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstancePossiblePlacements_v2')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetGpuInstancePossiblePlacements_v2 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstancePossiblePlacements_v2 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetGpuInstancePossible);

                /* "cuda/bindings/_internal/_nvml.pyx":2549
 *         global __nvmlDeviceGetGpuInstancePossiblePlacements_v2
 *         __nvmlDeviceGetGpuInstancePossiblePlacements_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstancePossiblePlacements_v2')
 *         if __nvmlDeviceGetGpuInstancePossiblePlacements_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstancePossiblePlacements_v2 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2550
 *         __nvmlDeviceGetGpuInstancePossiblePlacements_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstancePossiblePlacements_v2')
 *         if __nvmlDeviceGetGpuInstancePossiblePlacements_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuInstancePossiblePlacements_v2 = dlsym(handle, 'nvmlDeviceGetGpuInstancePossiblePlacements_v2')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2551
 *         if __nvmlDeviceGetGpuInstancePossiblePlacements_v2 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetGpuInstancePossiblePlacements_v2 = dlsym(handle, 'nvmlDeviceGetGpuInstancePossiblePlacements_v2')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2551, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2550
 *         __nvmlDeviceGetGpuInstancePossiblePlacements_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstancePossiblePlacements_v2')
 *         if __nvmlDeviceGetGpuInstancePossiblePlacements_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuInstancePossiblePlacements_v2 = dlsym(handle, 'nvmlDeviceGetGpuInstancePossiblePlacements_v2')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2552
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuInstancePossiblePlacements_v2 = dlsym(handle, 'nvmlDeviceGetGpuInstancePossiblePlacements_v2')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetGpuInstanceRemainingCapacity
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstancePossiblePlacements_v2 = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetGpuInstancePossible);

                  /* "cuda/bindings/_internal/_nvml.pyx":2549
 *         global __nvmlDeviceGetGpuInstancePossiblePlacements_v2
 *         __nvmlDeviceGetGpuInstancePossiblePlacements_v2 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstancePossiblePlacements_v2')
 *         if __nvmlDeviceGetGpuInstancePossiblePlacements_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2555
 * 
 *         global __nvmlDeviceGetGpuInstanceRemainingCapacity
 *         __nvmlDeviceGetGpuInstanceRemainingCapacity = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceRemainingCapacity')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetGpuInstanceRemainingCapacity == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceRemainingCapacity = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetGpuInstanceRemainin);

                /* "cuda/bindings/_internal/_nvml.pyx":2556
 *         global __nvmlDeviceGetGpuInstanceRemainingCapacity
 *         __nvmlDeviceGetGpuInstanceRemainingCapacity = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceRemainingCapacity')
 *         if __nvmlDeviceGetGpuInstanceRemainingCapacity == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceRemainingCapacity == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2557
 *         __nvmlDeviceGetGpuInstanceRemainingCapacity = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceRemainingCapacity')
 *         if __nvmlDeviceGetGpuInstanceRemainingCapacity == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuInstanceRemainingCapacity = dlsym(handle, 'nvmlDeviceGetGpuInstanceRemainingCapacity')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2558
 *         if __nvmlDeviceGetGpuInstanceRemainingCapacity == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetGpuInstanceRemainingCapacity = dlsym(handle, 'nvmlDeviceGetGpuInstanceRemainingCapacity')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2558, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2557
 *         __nvmlDeviceGetGpuInstanceRemainingCapacity = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceRemainingCapacity')
 *         if __nvmlDeviceGetGpuInstanceRemainingCapacity == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuInstanceRemainingCapacity = dlsym(handle, 'nvmlDeviceGetGpuInstanceRemainingCapacity')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2559
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuInstanceRemainingCapacity = dlsym(handle, 'nvmlDeviceGetGpuInstanceRemainingCapacity')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceCreateGpuInstance
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceRemainingCapacity = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetGpuInstanceRemainin);

                  /* "cuda/bindings/_internal/_nvml.pyx":2556
 *         global __nvmlDeviceGetGpuInstanceRemainingCapacity
 *         __nvmlDeviceGetGpuInstanceRemainingCapacity = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceRemainingCapacity')
 *         if __nvmlDeviceGetGpuInstanceRemainingCapacity == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2562
 * 
 *         global __nvmlDeviceCreateGpuInstance
 *         __nvmlDeviceCreateGpuInstance = dlsym(RTLD_DEFAULT, 'nvmlDeviceCreateGpuInstance')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceCreateGpuInstance == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceCreateGpuInstance = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceCreateGpuInstance);

                /* "cuda/bindings/_internal/_nvml.pyx":2563
 *         global __nvmlDeviceCreateGpuInstance
 *         __nvmlDeviceCreateGpuInstance = dlsym(RTLD_DEFAULT, 'nvmlDeviceCreateGpuInstance')
 *         if __nvmlDeviceCreateGpuInstance == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceCreateGpuInstance == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2564
 *         __nvmlDeviceCreateGpuInstance = dlsym(RTLD_DEFAULT, 'nvmlDeviceCreateGpuInstance')
 *         if __nvmlDeviceCreateGpuInstance == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceCreateGpuInstance = dlsym(handle, 'nvmlDeviceCreateGpuInstance')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2565
 *         if __nvmlDeviceCreateGpuInstance == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceCreateGpuInstance = dlsym(handle, 'nvmlDeviceCreateGpuInstance')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2565, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2564
 *         __nvmlDeviceCreateGpuInstance = dlsym(RTLD_DEFAULT, 'nvmlDeviceCreateGpuInstance')
 *         if __nvmlDeviceCreateGpuInstance == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceCreateGpuInstance = dlsym(handle, 'nvmlDeviceCreateGpuInstance')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2566
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceCreateGpuInstance = dlsym(handle, 'nvmlDeviceCreateGpuInstance')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceCreateGpuInstanceWithPlacement
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceCreateGpuInstance = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceCreateGpuInstance);

                  /* "cuda/bindings/_internal/_nvml.pyx":2563
 *         global __nvmlDeviceCreateGpuInstance
 *         __nvmlDeviceCreateGpuInstance = dlsym(RTLD_DEFAULT, 'nvmlDeviceCreateGpuInstance')
 *         if __nvmlDeviceCreateGpuInstance == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2569
 * 
 *         global __nvmlDeviceCreateGpuInstanceWithPlacement
 *         __nvmlDeviceCreateGpuInstanceWithPlacement = dlsym(RTLD_DEFAULT, 'nvmlDeviceCreateGpuInstanceWithPlacement')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceCreateGpuInstanceWithPlacement == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceCreateGpuInstanceWithPlacement = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceCreateGpuInstanceWithP);

                /* "cuda/bindings/_internal/_nvml.pyx":2570
 *         global __nvmlDeviceCreateGpuInstanceWithPlacement
 *         __nvmlDeviceCreateGpuInstanceWithPlacement = dlsym(RTLD_DEFAULT, 'nvmlDeviceCreateGpuInstanceWithPlacement')
 *         if __nvmlDeviceCreateGpuInstanceWithPlacement == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceCreateGpuInstanceWithPlacement == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2571
 *         __nvmlDeviceCreateGpuInstanceWithPlacement = dlsym(RTLD_DEFAULT, 'nvmlDeviceCreateGpuInstanceWithPlacement')
 *         if __nvmlDeviceCreateGpuInstanceWithPlacement == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceCreateGpuInstanceWithPlacement = dlsym(handle, 'nvmlDeviceCreateGpuInstanceWithPlacement')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2572
 *         if __nvmlDeviceCreateGpuInstanceWithPlacement == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceCreateGpuInstanceWithPlacement = dlsym(handle, 'nvmlDeviceCreateGpuInstanceWithPlacement')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2572, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2571
 *         __nvmlDeviceCreateGpuInstanceWithPlacement = dlsym(RTLD_DEFAULT, 'nvmlDeviceCreateGpuInstanceWithPlacement')
 *         if __nvmlDeviceCreateGpuInstanceWithPlacement == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceCreateGpuInstanceWithPlacement = dlsym(handle, 'nvmlDeviceCreateGpuInstanceWithPlacement')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2573
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceCreateGpuInstanceWithPlacement = dlsym(handle, 'nvmlDeviceCreateGpuInstanceWithPlacement')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGpuInstanceDestroy
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceCreateGpuInstanceWithPlacement = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceCreateGpuInstanceWithP);

                  /* "cuda/bindings/_internal/_nvml.pyx":2570
 *         global __nvmlDeviceCreateGpuInstanceWithPlacement
 *         __nvmlDeviceCreateGpuInstanceWithPlacement = dlsym(RTLD_DEFAULT, 'nvmlDeviceCreateGpuInstanceWithPlacement')
 *         if __nvmlDeviceCreateGpuInstanceWithPlacement == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2576
 * 
 *         global __nvmlGpuInstanceDestroy
 *         __nvmlGpuInstanceDestroy = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceDestroy')             # <<<<<<<<<<<<<<
 *         if __nvmlGpuInstanceDestroy == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceDestroy = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGpuInstanceDestroy);

                /* "cuda/bindings/_internal/_nvml.pyx":2577
 *         global __nvmlGpuInstanceDestroy
 *         __nvmlGpuInstanceDestroy = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceDestroy')
 *         if __nvmlGpuInstanceDestroy == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceDestroy == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2578
 *         __nvmlGpuInstanceDestroy = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceDestroy')
 *         if __nvmlGpuInstanceDestroy == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceDestroy = dlsym(handle, 'nvmlGpuInstanceDestroy')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2579
 *         if __nvmlGpuInstanceDestroy == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGpuInstanceDestroy = dlsym(handle, 'nvmlGpuInstanceDestroy')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2579, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2578
 *         __nvmlGpuInstanceDestroy = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceDestroy')
 *         if __nvmlGpuInstanceDestroy == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceDestroy = dlsym(handle, 'nvmlGpuInstanceDestroy')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2580
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGpuInstanceDestroy = dlsym(handle, 'nvmlGpuInstanceDestroy')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetGpuInstances
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceDestroy = dlsym(__pyx_v_handle, __pyx_k_nvmlGpuInstanceDestroy);

                  /* "cuda/bindings/_internal/_nvml.pyx":2577
 *         global __nvmlGpuInstanceDestroy
 *         __nvmlGpuInstanceDestroy = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceDestroy')
 *         if __nvmlGpuInstanceDestroy == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2583
 * 
 *         global __nvmlDeviceGetGpuInstances
 *         __nvmlDeviceGetGpuInstances = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstances')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetGpuInstances == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstances = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetGpuInstances);

                /* "cuda/bindings/_internal/_nvml.pyx":2584
 *         global __nvmlDeviceGetGpuInstances
 *         __nvmlDeviceGetGpuInstances = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstances')
 *         if __nvmlDeviceGetGpuInstances == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstances == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2585
 *         __nvmlDeviceGetGpuInstances = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstances')
 *         if __nvmlDeviceGetGpuInstances == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuInstances = dlsym(handle, 'nvmlDeviceGetGpuInstances')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2586
 *         if __nvmlDeviceGetGpuInstances == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetGpuInstances = dlsym(handle, 'nvmlDeviceGetGpuInstances')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2586, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2585
 *         __nvmlDeviceGetGpuInstances = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstances')
 *         if __nvmlDeviceGetGpuInstances == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuInstances = dlsym(handle, 'nvmlDeviceGetGpuInstances')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2587
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuInstances = dlsym(handle, 'nvmlDeviceGetGpuInstances')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetGpuInstanceById
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstances = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetGpuInstances);

                  /* "cuda/bindings/_internal/_nvml.pyx":2584
 *         global __nvmlDeviceGetGpuInstances
 *         __nvmlDeviceGetGpuInstances = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstances')
 *         if __nvmlDeviceGetGpuInstances == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2590
 * 
 *         global __nvmlDeviceGetGpuInstanceById
 *         __nvmlDeviceGetGpuInstanceById = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceById')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetGpuInstanceById == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceById = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetGpuInstanceById);

                /* "cuda/bindings/_internal/_nvml.pyx":2591
 *         global __nvmlDeviceGetGpuInstanceById
 *         __nvmlDeviceGetGpuInstanceById = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceById')
 *         if __nvmlDeviceGetGpuInstanceById == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceById == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2592
 *         __nvmlDeviceGetGpuInstanceById = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceById')
 *         if __nvmlDeviceGetGpuInstanceById == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuInstanceById = dlsym(handle, 'nvmlDeviceGetGpuInstanceById')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2593
 *         if __nvmlDeviceGetGpuInstanceById == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetGpuInstanceById = dlsym(handle, 'nvmlDeviceGetGpuInstanceById')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2593, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2592
 *         __nvmlDeviceGetGpuInstanceById = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceById')
 *         if __nvmlDeviceGetGpuInstanceById == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuInstanceById = dlsym(handle, 'nvmlDeviceGetGpuInstanceById')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2594
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuInstanceById = dlsym(handle, 'nvmlDeviceGetGpuInstanceById')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGpuInstanceGetInfo
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceById = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetGpuInstanceById);

                  /* "cuda/bindings/_internal/_nvml.pyx":2591
 *         global __nvmlDeviceGetGpuInstanceById
 *         __nvmlDeviceGetGpuInstanceById = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceById')
 *         if __nvmlDeviceGetGpuInstanceById == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2597
 * 
 *         global __nvmlGpuInstanceGetInfo
 *         __nvmlGpuInstanceGetInfo = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetInfo')             # <<<<<<<<<<<<<<
 *         if __nvmlGpuInstanceGetInfo == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetInfo = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGpuInstanceGetInfo);

                /* "cuda/bindings/_internal/_nvml.pyx":2598
 *         global __nvmlGpuInstanceGetInfo
 *         __nvmlGpuInstanceGetInfo = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetInfo')
 *         if __nvmlGpuInstanceGetInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetInfo == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2599
 *         __nvmlGpuInstanceGetInfo = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetInfo')
 *         if __nvmlGpuInstanceGetInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetInfo = dlsym(handle, 'nvmlGpuInstanceGetInfo')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2600
 *         if __nvmlGpuInstanceGetInfo == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGpuInstanceGetInfo = dlsym(handle, 'nvmlGpuInstanceGetInfo')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2600, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2599
 *         __nvmlGpuInstanceGetInfo = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetInfo')
 *         if __nvmlGpuInstanceGetInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetInfo = dlsym(handle, 'nvmlGpuInstanceGetInfo')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2601
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetInfo = dlsym(handle, 'nvmlGpuInstanceGetInfo')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGpuInstanceGetComputeInstanceProfileInfoV
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetInfo = dlsym(__pyx_v_handle, __pyx_k_nvmlGpuInstanceGetInfo);

                  /* "cuda/bindings/_internal/_nvml.pyx":2598
 *         global __nvmlGpuInstanceGetInfo
 *         __nvmlGpuInstanceGetInfo = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetInfo')
 *         if __nvmlGpuInstanceGetInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2604
 * 
 *         global __nvmlGpuInstanceGetComputeInstanceProfileInfoV
 *         __nvmlGpuInstanceGetComputeInstanceProfileInfoV = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstanceProfileInfoV')             # <<<<<<<<<<<<<<
 *         if __nvmlGpuInstanceGetComputeInstanceProfileInfoV == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstanceProfileInfoV = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGpuInstanceGetComputeInstanc);

                /* "cuda/bindings/_internal/_nvml.pyx":2605
 *         global __nvmlGpuInstanceGetComputeInstanceProfileInfoV
 *         __nvmlGpuInstanceGetComputeInstanceProfileInfoV = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstanceProfileInfoV')
 *         if __nvmlGpuInstanceGetComputeInstanceProfileInfoV == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstanceProfileInfoV == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2606
 *         __nvmlGpuInstanceGetComputeInstanceProfileInfoV = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstanceProfileInfoV')
 *         if __nvmlGpuInstanceGetComputeInstanceProfileInfoV == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetComputeInstanceProfileInfoV = dlsym(handle, 'nvmlGpuInstanceGetComputeInstanceProfileInfoV')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2607
 *         if __nvmlGpuInstanceGetComputeInstanceProfileInfoV == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGpuInstanceGetComputeInstanceProfileInfoV = dlsym(handle, 'nvmlGpuInstanceGetComputeInstanceProfileInfoV')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2607, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2606
 *         __nvmlGpuInstanceGetComputeInstanceProfileInfoV = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstanceProfileInfoV')
 *         if __nvmlGpuInstanceGetComputeInstanceProfileInfoV == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetComputeInstanceProfileInfoV = dlsym(handle, 'nvmlGpuInstanceGetComputeInstanceProfileInfoV')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2608
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetComputeInstanceProfileInfoV = dlsym(handle, 'nvmlGpuInstanceGetComputeInstanceProfileInfoV')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGpuInstanceGetComputeInstanceRemainingCapacity
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstanceProfileInfoV = dlsym(__pyx_v_handle, __pyx_k_nvmlGpuInstanceGetComputeInstanc);

                  /* "cuda/bindings/_internal/_nvml.pyx":2605
 *         global __nvmlGpuInstanceGetComputeInstanceProfileInfoV
 *         __nvmlGpuInstanceGetComputeInstanceProfileInfoV = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstanceProfileInfoV')
 *         if __nvmlGpuInstanceGetComputeInstanceProfileInfoV == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2611
 * 
 *         global __nvmlGpuInstanceGetComputeInstanceRemainingCapacity
 *         __nvmlGpuInstanceGetComputeInstanceRemainingCapacity = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstanceRemainingCapacity')             # <<<<<<<<<<<<<<
 *         if __nvmlGpuInstanceGetComputeInstanceRemainingCapacity == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstanceRemainingCapacity = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGpuInstanceGetComputeInstanc_2);

                /* "cuda/bindings/_internal/_nvml.pyx":2612
 *         global __nvmlGpuInstanceGetComputeInstanceRemainingCapacity
 *         __nvmlGpuInstanceGetComputeInstanceRemainingCapacity = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstanceRemainingCapacity')
 *         if __nvmlGpuInstanceGetComputeInstanceRemainingCapacity == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstanceRemainingCapacity == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2613
 *         __nvmlGpuInstanceGetComputeInstanceRemainingCapacity = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstanceRemainingCapacity')
 *         if __nvmlGpuInstanceGetComputeInstanceRemainingCapacity == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetComputeInstanceRemainingCapacity = dlsym(handle, 'nvmlGpuInstanceGetComputeInstanceRemainingCapacity')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2614
 *         if __nvmlGpuInstanceGetComputeInstanceRemainingCapacity == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGpuInstanceGetComputeInstanceRemainingCapacity = dlsym(handle, 'nvmlGpuInstanceGetComputeInstanceRemainingCapacity')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2614, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2613
 *         __nvmlGpuInstanceGetComputeInstanceRemainingCapacity = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstanceRemainingCapacity')
 *         if __nvmlGpuInstanceGetComputeInstanceRemainingCapacity == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetComputeInstanceRemainingCapacity = dlsym(handle, 'nvmlGpuInstanceGetComputeInstanceRemainingCapacity')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2615
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetComputeInstanceRemainingCapacity = dlsym(handle, 'nvmlGpuInstanceGetComputeInstanceRemainingCapacity')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGpuInstanceGetComputeInstancePossiblePlacements
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstanceRemainingCapacity = dlsym(__pyx_v_handle, __pyx_k_nvmlGpuInstanceGetComputeInstanc_2);

                  /* "cuda/bindings/_internal/_nvml.pyx":2612
 *         global __nvmlGpuInstanceGetComputeInstanceRemainingCapacity
 *         __nvmlGpuInstanceGetComputeInstanceRemainingCapacity = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstanceRemainingCapacity')
 *         if __nvmlGpuInstanceGetComputeInstanceRemainingCapacity == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2618
 * 
 *         global __nvmlGpuInstanceGetComputeInstancePossiblePlacements
 *         __nvmlGpuInstanceGetComputeInstancePossiblePlacements = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstancePossiblePlacements')             # <<<<<<<<<<<<<<
 *         if __nvmlGpuInstanceGetComputeInstancePossiblePlacements == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstancePossiblePlacements = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGpuInstanceGetComputeInstanc_3);

                /* "cuda/bindings/_internal/_nvml.pyx":2619
 *         global __nvmlGpuInstanceGetComputeInstancePossiblePlacements
 *         __nvmlGpuInstanceGetComputeInstancePossiblePlacements = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstancePossiblePlacements')
 *         if __nvmlGpuInstanceGetComputeInstancePossiblePlacements == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstancePossiblePlacements == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2620
 *         __nvmlGpuInstanceGetComputeInstancePossiblePlacements = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstancePossiblePlacements')
 *         if __nvmlGpuInstanceGetComputeInstancePossiblePlacements == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetComputeInstancePossiblePlacements = dlsym(handle, 'nvmlGpuInstanceGetComputeInstancePossiblePlacements')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2621
 *         if __nvmlGpuInstanceGetComputeInstancePossiblePlacements == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGpuInstanceGetComputeInstancePossiblePlacements = dlsym(handle, 'nvmlGpuInstanceGetComputeInstancePossiblePlacements')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2621, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2620
 *         __nvmlGpuInstanceGetComputeInstancePossiblePlacements = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstancePossiblePlacements')
 *         if __nvmlGpuInstanceGetComputeInstancePossiblePlacements == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetComputeInstancePossiblePlacements = dlsym(handle, 'nvmlGpuInstanceGetComputeInstancePossiblePlacements')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2622
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetComputeInstancePossiblePlacements = dlsym(handle, 'nvmlGpuInstanceGetComputeInstancePossiblePlacements')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGpuInstanceCreateComputeInstance
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstancePossiblePlacements = dlsym(__pyx_v_handle, __pyx_k_nvmlGpuInstanceGetComputeInstanc_3);

                  /* "cuda/bindings/_internal/_nvml.pyx":2619
 *         global __nvmlGpuInstanceGetComputeInstancePossiblePlacements
 *         __nvmlGpuInstanceGetComputeInstancePossiblePlacements = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstancePossiblePlacements')
 *         if __nvmlGpuInstanceGetComputeInstancePossiblePlacements == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2625
 * 
 *         global __nvmlGpuInstanceCreateComputeInstance
 *         __nvmlGpuInstanceCreateComputeInstance = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceCreateComputeInstance')             # <<<<<<<<<<<<<<
 *         if __nvmlGpuInstanceCreateComputeInstance == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceCreateComputeInstance = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGpuInstanceCreateComputeInst);

                /* "cuda/bindings/_internal/_nvml.pyx":2626
 *         global __nvmlGpuInstanceCreateComputeInstance
 *         __nvmlGpuInstanceCreateComputeInstance = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceCreateComputeInstance')
 *         if __nvmlGpuInstanceCreateComputeInstance == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceCreateComputeInstance == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2627
 *         __nvmlGpuInstanceCreateComputeInstance = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceCreateComputeInstance')
 *         if __nvmlGpuInstanceCreateComputeInstance == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceCreateComputeInstance = dlsym(handle, 'nvmlGpuInstanceCreateComputeInstance')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2628
 *         if __nvmlGpuInstanceCreateComputeInstance == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGpuInstanceCreateComputeInstance = dlsym(handle, 'nvmlGpuInstanceCreateComputeInstance')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2628, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2627
 *         __nvmlGpuInstanceCreateComputeInstance = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceCreateComputeInstance')
 *         if __nvmlGpuInstanceCreateComputeInstance == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceCreateComputeInstance = dlsym(handle, 'nvmlGpuInstanceCreateComputeInstance')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2629
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGpuInstanceCreateComputeInstance = dlsym(handle, 'nvmlGpuInstanceCreateComputeInstance')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGpuInstanceCreateComputeInstanceWithPlacement
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceCreateComputeInstance = dlsym(__pyx_v_handle, __pyx_k_nvmlGpuInstanceCreateComputeInst);

                  /* "cuda/bindings/_internal/_nvml.pyx":2626
 *         global __nvmlGpuInstanceCreateComputeInstance
 *         __nvmlGpuInstanceCreateComputeInstance = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceCreateComputeInstance')
 *         if __nvmlGpuInstanceCreateComputeInstance == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2632
 * 
 *         global __nvmlGpuInstanceCreateComputeInstanceWithPlacement
 *         __nvmlGpuInstanceCreateComputeInstanceWithPlacement = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceCreateComputeInstanceWithPlacement')             # <<<<<<<<<<<<<<
 *         if __nvmlGpuInstanceCreateComputeInstanceWithPlacement == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceCreateComputeInstanceWithPlacement = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGpuInstanceCreateComputeInst_2);

                /* "cuda/bindings/_internal/_nvml.pyx":2633
 *         global __nvmlGpuInstanceCreateComputeInstanceWithPlacement
 *         __nvmlGpuInstanceCreateComputeInstanceWithPlacement = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceCreateComputeInstanceWithPlacement')
 *         if __nvmlGpuInstanceCreateComputeInstanceWithPlacement == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceCreateComputeInstanceWithPlacement == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2634
 *         __nvmlGpuInstanceCreateComputeInstanceWithPlacement = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceCreateComputeInstanceWithPlacement')
 *         if __nvmlGpuInstanceCreateComputeInstanceWithPlacement == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceCreateComputeInstanceWithPlacement = dlsym(handle, 'nvmlGpuInstanceCreateComputeInstanceWithPlacement')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2635
 *         if __nvmlGpuInstanceCreateComputeInstanceWithPlacement == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGpuInstanceCreateComputeInstanceWithPlacement = dlsym(handle, 'nvmlGpuInstanceCreateComputeInstanceWithPlacement')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2635, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2634
 *         __nvmlGpuInstanceCreateComputeInstanceWithPlacement = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceCreateComputeInstanceWithPlacement')
 *         if __nvmlGpuInstanceCreateComputeInstanceWithPlacement == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceCreateComputeInstanceWithPlacement = dlsym(handle, 'nvmlGpuInstanceCreateComputeInstanceWithPlacement')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2636
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGpuInstanceCreateComputeInstanceWithPlacement = dlsym(handle, 'nvmlGpuInstanceCreateComputeInstanceWithPlacement')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlComputeInstanceDestroy
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceCreateComputeInstanceWithPlacement = dlsym(__pyx_v_handle, __pyx_k_nvmlGpuInstanceCreateComputeInst_2);

                  /* "cuda/bindings/_internal/_nvml.pyx":2633
 *         global __nvmlGpuInstanceCreateComputeInstanceWithPlacement
 *         __nvmlGpuInstanceCreateComputeInstanceWithPlacement = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceCreateComputeInstanceWithPlacement')
 *         if __nvmlGpuInstanceCreateComputeInstanceWithPlacement == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2639
 * 
 *         global __nvmlComputeInstanceDestroy
 *         __nvmlComputeInstanceDestroy = dlsym(RTLD_DEFAULT, 'nvmlComputeInstanceDestroy')             # <<<<<<<<<<<<<<
 *         if __nvmlComputeInstanceDestroy == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlComputeInstanceDestroy = dlsym(RTLD_DEFAULT, __pyx_k_nvmlComputeInstanceDestroy);

                /* "cuda/bindings/_internal/_nvml.pyx":2640
 *         global __nvmlComputeInstanceDestroy
 *         __nvmlComputeInstanceDestroy = dlsym(RTLD_DEFAULT, 'nvmlComputeInstanceDestroy')
 *         if __nvmlComputeInstanceDestroy == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlComputeInstanceDestroy == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2641
 *         __nvmlComputeInstanceDestroy = dlsym(RTLD_DEFAULT, 'nvmlComputeInstanceDestroy')
 *         if __nvmlComputeInstanceDestroy == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlComputeInstanceDestroy = dlsym(handle, 'nvmlComputeInstanceDestroy')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2642
 *         if __nvmlComputeInstanceDestroy == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlComputeInstanceDestroy = dlsym(handle, 'nvmlComputeInstanceDestroy')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2642, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2641
 *         __nvmlComputeInstanceDestroy = dlsym(RTLD_DEFAULT, 'nvmlComputeInstanceDestroy')
 *         if __nvmlComputeInstanceDestroy == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlComputeInstanceDestroy = dlsym(handle, 'nvmlComputeInstanceDestroy')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2643
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlComputeInstanceDestroy = dlsym(handle, 'nvmlComputeInstanceDestroy')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGpuInstanceGetComputeInstances
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlComputeInstanceDestroy = dlsym(__pyx_v_handle, __pyx_k_nvmlComputeInstanceDestroy);

                  /* "cuda/bindings/_internal/_nvml.pyx":2640
 *         global __nvmlComputeInstanceDestroy
 *         __nvmlComputeInstanceDestroy = dlsym(RTLD_DEFAULT, 'nvmlComputeInstanceDestroy')
 *         if __nvmlComputeInstanceDestroy == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2646
 * 
 *         global __nvmlGpuInstanceGetComputeInstances
 *         __nvmlGpuInstanceGetComputeInstances = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstances')             # <<<<<<<<<<<<<<
 *         if __nvmlGpuInstanceGetComputeInstances == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstances = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGpuInstanceGetComputeInstanc_4);

                /* "cuda/bindings/_internal/_nvml.pyx":2647
 *         global __nvmlGpuInstanceGetComputeInstances
 *         __nvmlGpuInstanceGetComputeInstances = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstances')
 *         if __nvmlGpuInstanceGetComputeInstances == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstances == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2648
 *         __nvmlGpuInstanceGetComputeInstances = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstances')
 *         if __nvmlGpuInstanceGetComputeInstances == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetComputeInstances = dlsym(handle, 'nvmlGpuInstanceGetComputeInstances')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2649
 *         if __nvmlGpuInstanceGetComputeInstances == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGpuInstanceGetComputeInstances = dlsym(handle, 'nvmlGpuInstanceGetComputeInstances')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2649, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2648
 *         __nvmlGpuInstanceGetComputeInstances = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstances')
 *         if __nvmlGpuInstanceGetComputeInstances == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetComputeInstances = dlsym(handle, 'nvmlGpuInstanceGetComputeInstances')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2650
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetComputeInstances = dlsym(handle, 'nvmlGpuInstanceGetComputeInstances')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGpuInstanceGetComputeInstanceById
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstances = dlsym(__pyx_v_handle, __pyx_k_nvmlGpuInstanceGetComputeInstanc_4);

                  /* "cuda/bindings/_internal/_nvml.pyx":2647
 *         global __nvmlGpuInstanceGetComputeInstances
 *         __nvmlGpuInstanceGetComputeInstances = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstances')
 *         if __nvmlGpuInstanceGetComputeInstances == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2653
 * 
 *         global __nvmlGpuInstanceGetComputeInstanceById
 *         __nvmlGpuInstanceGetComputeInstanceById = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstanceById')             # <<<<<<<<<<<<<<
 *         if __nvmlGpuInstanceGetComputeInstanceById == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstanceById = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGpuInstanceGetComputeInstanc_5);

                /* "cuda/bindings/_internal/_nvml.pyx":2654
 *         global __nvmlGpuInstanceGetComputeInstanceById
 *         __nvmlGpuInstanceGetComputeInstanceById = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstanceById')
 *         if __nvmlGpuInstanceGetComputeInstanceById == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstanceById == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2655
 *         __nvmlGpuInstanceGetComputeInstanceById = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstanceById')
 *         if __nvmlGpuInstanceGetComputeInstanceById == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetComputeInstanceById = dlsym(handle, 'nvmlGpuInstanceGetComputeInstanceById')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2656
 *         if __nvmlGpuInstanceGetComputeInstanceById == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGpuInstanceGetComputeInstanceById = dlsym(handle, 'nvmlGpuInstanceGetComputeInstanceById')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2656, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2655
 *         __nvmlGpuInstanceGetComputeInstanceById = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstanceById')
 *         if __nvmlGpuInstanceGetComputeInstanceById == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetComputeInstanceById = dlsym(handle, 'nvmlGpuInstanceGetComputeInstanceById')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2657
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGpuInstanceGetComputeInstanceById = dlsym(handle, 'nvmlGpuInstanceGetComputeInstanceById')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlComputeInstanceGetInfo_v2
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstanceById = dlsym(__pyx_v_handle, __pyx_k_nvmlGpuInstanceGetComputeInstanc_5);

                  /* "cuda/bindings/_internal/_nvml.pyx":2654
 *         global __nvmlGpuInstanceGetComputeInstanceById
 *         __nvmlGpuInstanceGetComputeInstanceById = dlsym(RTLD_DEFAULT, 'nvmlGpuInstanceGetComputeInstanceById')
 *         if __nvmlGpuInstanceGetComputeInstanceById == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2660
 * 
 *         global __nvmlComputeInstanceGetInfo_v2
 *         __nvmlComputeInstanceGetInfo_v2 = dlsym(RTLD_DEFAULT, 'nvmlComputeInstanceGetInfo_v2')             # <<<<<<<<<<<<<<
 *         if __nvmlComputeInstanceGetInfo_v2 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlComputeInstanceGetInfo_v2 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlComputeInstanceGetInfo_v2);

                /* "cuda/bindings/_internal/_nvml.pyx":2661
 *         global __nvmlComputeInstanceGetInfo_v2
 *         __nvmlComputeInstanceGetInfo_v2 = dlsym(RTLD_DEFAULT, 'nvmlComputeInstanceGetInfo_v2')
 *         if __nvmlComputeInstanceGetInfo_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlComputeInstanceGetInfo_v2 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2662
 *         __nvmlComputeInstanceGetInfo_v2 = dlsym(RTLD_DEFAULT, 'nvmlComputeInstanceGetInfo_v2')
 *         if __nvmlComputeInstanceGetInfo_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlComputeInstanceGetInfo_v2 = dlsym(handle, 'nvmlComputeInstanceGetInfo_v2')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2663
 *         if __nvmlComputeInstanceGetInfo_v2 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlComputeInstanceGetInfo_v2 = dlsym(handle, 'nvmlComputeInstanceGetInfo_v2')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2663, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2662
 *         __nvmlComputeInstanceGetInfo_v2 = dlsym(RTLD_DEFAULT, 'nvmlComputeInstanceGetInfo_v2')
 *         if __nvmlComputeInstanceGetInfo_v2 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlComputeInstanceGetInfo_v2 = dlsym(handle, 'nvmlComputeInstanceGetInfo_v2')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2664
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlComputeInstanceGetInfo_v2 = dlsym(handle, 'nvmlComputeInstanceGetInfo_v2')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceIsMigDeviceHandle
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlComputeInstanceGetInfo_v2 = dlsym(__pyx_v_handle, __pyx_k_nvmlComputeInstanceGetInfo_v2);

                  /* "cuda/bindings/_internal/_nvml.pyx":2661
 *         global __nvmlComputeInstanceGetInfo_v2
 *         __nvmlComputeInstanceGetInfo_v2 = dlsym(RTLD_DEFAULT, 'nvmlComputeInstanceGetInfo_v2')
 *         if __nvmlComputeInstanceGetInfo_v2 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2667
 * 
 *         global __nvmlDeviceIsMigDeviceHandle
 *         __nvmlDeviceIsMigDeviceHandle = dlsym(RTLD_DEFAULT, 'nvmlDeviceIsMigDeviceHandle')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceIsMigDeviceHandle == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceIsMigDeviceHandle = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceIsMigDeviceHandle);

                /* "cuda/bindings/_internal/_nvml.pyx":2668
 *         global __nvmlDeviceIsMigDeviceHandle
 *         __nvmlDeviceIsMigDeviceHandle = dlsym(RTLD_DEFAULT, 'nvmlDeviceIsMigDeviceHandle')
 *         if __nvmlDeviceIsMigDeviceHandle == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceIsMigDeviceHandle == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2669
 *         __nvmlDeviceIsMigDeviceHandle = dlsym(RTLD_DEFAULT, 'nvmlDeviceIsMigDeviceHandle')
 *         if __nvmlDeviceIsMigDeviceHandle == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceIsMigDeviceHandle = dlsym(handle, 'nvmlDeviceIsMigDeviceHandle')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2670
 *         if __nvmlDeviceIsMigDeviceHandle == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceIsMigDeviceHandle = dlsym(handle, 'nvmlDeviceIsMigDeviceHandle')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2670, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2669
 *         __nvmlDeviceIsMigDeviceHandle = dlsym(RTLD_DEFAULT, 'nvmlDeviceIsMigDeviceHandle')
 *         if __nvmlDeviceIsMigDeviceHandle == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceIsMigDeviceHandle = dlsym(handle, 'nvmlDeviceIsMigDeviceHandle')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2671
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceIsMigDeviceHandle = dlsym(handle, 'nvmlDeviceIsMigDeviceHandle')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetGpuInstanceId
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceIsMigDeviceHandle = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceIsMigDeviceHandle);

                  /* "cuda/bindings/_internal/_nvml.pyx":2668
 *         global __nvmlDeviceIsMigDeviceHandle
 *         __nvmlDeviceIsMigDeviceHandle = dlsym(RTLD_DEFAULT, 'nvmlDeviceIsMigDeviceHandle')
 *         if __nvmlDeviceIsMigDeviceHandle == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2674
 * 
 *         global __nvmlDeviceGetGpuInstanceId
 *         __nvmlDeviceGetGpuInstanceId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceId')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetGpuInstanceId == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceId = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetGpuInstanceId);

                /* "cuda/bindings/_internal/_nvml.pyx":2675
 *         global __nvmlDeviceGetGpuInstanceId
 *         __nvmlDeviceGetGpuInstanceId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceId')
 *         if __nvmlDeviceGetGpuInstanceId == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceId == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2676
 *         __nvmlDeviceGetGpuInstanceId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceId')
 *         if __nvmlDeviceGetGpuInstanceId == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuInstanceId = dlsym(handle, 'nvmlDeviceGetGpuInstanceId')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2677
 *         if __nvmlDeviceGetGpuInstanceId == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetGpuInstanceId = dlsym(handle, 'nvmlDeviceGetGpuInstanceId')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2677, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2676
 *         __nvmlDeviceGetGpuInstanceId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceId')
 *         if __nvmlDeviceGetGpuInstanceId == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuInstanceId = dlsym(handle, 'nvmlDeviceGetGpuInstanceId')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2678
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuInstanceId = dlsym(handle, 'nvmlDeviceGetGpuInstanceId')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetComputeInstanceId
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceId = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetGpuInstanceId);

                  /* "cuda/bindings/_internal/_nvml.pyx":2675
 *         global __nvmlDeviceGetGpuInstanceId
 *         __nvmlDeviceGetGpuInstanceId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceId')
 *         if __nvmlDeviceGetGpuInstanceId == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2681
 * 
 *         global __nvmlDeviceGetComputeInstanceId
 *         __nvmlDeviceGetComputeInstanceId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetComputeInstanceId')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetComputeInstanceId == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetComputeInstanceId = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetComputeInstanceId);

                /* "cuda/bindings/_internal/_nvml.pyx":2682
 *         global __nvmlDeviceGetComputeInstanceId
 *         __nvmlDeviceGetComputeInstanceId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetComputeInstanceId')
 *         if __nvmlDeviceGetComputeInstanceId == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetComputeInstanceId == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2683
 *         __nvmlDeviceGetComputeInstanceId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetComputeInstanceId')
 *         if __nvmlDeviceGetComputeInstanceId == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetComputeInstanceId = dlsym(handle, 'nvmlDeviceGetComputeInstanceId')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2684
 *         if __nvmlDeviceGetComputeInstanceId == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetComputeInstanceId = dlsym(handle, 'nvmlDeviceGetComputeInstanceId')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2684, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2683
 *         __nvmlDeviceGetComputeInstanceId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetComputeInstanceId')
 *         if __nvmlDeviceGetComputeInstanceId == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetComputeInstanceId = dlsym(handle, 'nvmlDeviceGetComputeInstanceId')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2685
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetComputeInstanceId = dlsym(handle, 'nvmlDeviceGetComputeInstanceId')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetMaxMigDeviceCount
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetComputeInstanceId = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetComputeInstanceId);

                  /* "cuda/bindings/_internal/_nvml.pyx":2682
 *         global __nvmlDeviceGetComputeInstanceId
 *         __nvmlDeviceGetComputeInstanceId = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetComputeInstanceId')
 *         if __nvmlDeviceGetComputeInstanceId == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2688
 * 
 *         global __nvmlDeviceGetMaxMigDeviceCount
 *         __nvmlDeviceGetMaxMigDeviceCount = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxMigDeviceCount')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetMaxMigDeviceCount == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxMigDeviceCount = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetMaxMigDeviceCount);

                /* "cuda/bindings/_internal/_nvml.pyx":2689
 *         global __nvmlDeviceGetMaxMigDeviceCount
 *         __nvmlDeviceGetMaxMigDeviceCount = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxMigDeviceCount')
 *         if __nvmlDeviceGetMaxMigDeviceCount == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxMigDeviceCount == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2690
 *         __nvmlDeviceGetMaxMigDeviceCount = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxMigDeviceCount')
 *         if __nvmlDeviceGetMaxMigDeviceCount == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMaxMigDeviceCount = dlsym(handle, 'nvmlDeviceGetMaxMigDeviceCount')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2691
 *         if __nvmlDeviceGetMaxMigDeviceCount == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetMaxMigDeviceCount = dlsym(handle, 'nvmlDeviceGetMaxMigDeviceCount')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2691, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2690
 *         __nvmlDeviceGetMaxMigDeviceCount = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxMigDeviceCount')
 *         if __nvmlDeviceGetMaxMigDeviceCount == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMaxMigDeviceCount = dlsym(handle, 'nvmlDeviceGetMaxMigDeviceCount')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2692
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetMaxMigDeviceCount = dlsym(handle, 'nvmlDeviceGetMaxMigDeviceCount')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetMigDeviceHandleByIndex
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxMigDeviceCount = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetMaxMigDeviceCount);

                  /* "cuda/bindings/_internal/_nvml.pyx":2689
 *         global __nvmlDeviceGetMaxMigDeviceCount
 *         __nvmlDeviceGetMaxMigDeviceCount = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMaxMigDeviceCount')
 *         if __nvmlDeviceGetMaxMigDeviceCount == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2695
 * 
 *         global __nvmlDeviceGetMigDeviceHandleByIndex
 *         __nvmlDeviceGetMigDeviceHandleByIndex = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMigDeviceHandleByIndex')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetMigDeviceHandleByIndex == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMigDeviceHandleByIndex = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetMigDeviceHandleByIn);

                /* "cuda/bindings/_internal/_nvml.pyx":2696
 *         global __nvmlDeviceGetMigDeviceHandleByIndex
 *         __nvmlDeviceGetMigDeviceHandleByIndex = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMigDeviceHandleByIndex')
 *         if __nvmlDeviceGetMigDeviceHandleByIndex == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMigDeviceHandleByIndex == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2697
 *         __nvmlDeviceGetMigDeviceHandleByIndex = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMigDeviceHandleByIndex')
 *         if __nvmlDeviceGetMigDeviceHandleByIndex == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMigDeviceHandleByIndex = dlsym(handle, 'nvmlDeviceGetMigDeviceHandleByIndex')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2698
 *         if __nvmlDeviceGetMigDeviceHandleByIndex == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetMigDeviceHandleByIndex = dlsym(handle, 'nvmlDeviceGetMigDeviceHandleByIndex')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2698, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2697
 *         __nvmlDeviceGetMigDeviceHandleByIndex = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMigDeviceHandleByIndex')
 *         if __nvmlDeviceGetMigDeviceHandleByIndex == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetMigDeviceHandleByIndex = dlsym(handle, 'nvmlDeviceGetMigDeviceHandleByIndex')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2699
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetMigDeviceHandleByIndex = dlsym(handle, 'nvmlDeviceGetMigDeviceHandleByIndex')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetDeviceHandleFromMigDeviceHandle
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMigDeviceHandleByIndex = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetMigDeviceHandleByIn);

                  /* "cuda/bindings/_internal/_nvml.pyx":2696
 *         global __nvmlDeviceGetMigDeviceHandleByIndex
 *         __nvmlDeviceGetMigDeviceHandleByIndex = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetMigDeviceHandleByIndex')
 *         if __nvmlDeviceGetMigDeviceHandleByIndex == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2702
 * 
 *         global __nvmlDeviceGetDeviceHandleFromMigDeviceHandle
 *         __nvmlDeviceGetDeviceHandleFromMigDeviceHandle = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDeviceHandleFromMigDeviceHandle')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetDeviceHandleFromMigDeviceHandle == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDeviceHandleFromMigDeviceHandle = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetDeviceHandleFromMig);

                /* "cuda/bindings/_internal/_nvml.pyx":2703
 *         global __nvmlDeviceGetDeviceHandleFromMigDeviceHandle
 *         __nvmlDeviceGetDeviceHandleFromMigDeviceHandle = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDeviceHandleFromMigDeviceHandle')
 *         if __nvmlDeviceGetDeviceHandleFromMigDeviceHandle == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDeviceHandleFromMigDeviceHandle == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2704
 *         __nvmlDeviceGetDeviceHandleFromMigDeviceHandle = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDeviceHandleFromMigDeviceHandle')
 *         if __nvmlDeviceGetDeviceHandleFromMigDeviceHandle == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetDeviceHandleFromMigDeviceHandle = dlsym(handle, 'nvmlDeviceGetDeviceHandleFromMigDeviceHandle')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2705
 *         if __nvmlDeviceGetDeviceHandleFromMigDeviceHandle == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetDeviceHandleFromMigDeviceHandle = dlsym(handle, 'nvmlDeviceGetDeviceHandleFromMigDeviceHandle')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2705, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2704
 *         __nvmlDeviceGetDeviceHandleFromMigDeviceHandle = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDeviceHandleFromMigDeviceHandle')
 *         if __nvmlDeviceGetDeviceHandleFromMigDeviceHandle == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetDeviceHandleFromMigDeviceHandle = dlsym(handle, 'nvmlDeviceGetDeviceHandleFromMigDeviceHandle')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2706
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetDeviceHandleFromMigDeviceHandle = dlsym(handle, 'nvmlDeviceGetDeviceHandleFromMigDeviceHandle')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGpmSampleGet
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDeviceHandleFromMigDeviceHandle = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetDeviceHandleFromMig);

                  /* "cuda/bindings/_internal/_nvml.pyx":2703
 *         global __nvmlDeviceGetDeviceHandleFromMigDeviceHandle
 *         __nvmlDeviceGetDeviceHandleFromMigDeviceHandle = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetDeviceHandleFromMigDeviceHandle')
 *         if __nvmlDeviceGetDeviceHandleFromMigDeviceHandle == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2709
 * 
 *         global __nvmlGpmSampleGet
 *         __nvmlGpmSampleGet = dlsym(RTLD_DEFAULT, 'nvmlGpmSampleGet')             # <<<<<<<<<<<<<<
 *         if __nvmlGpmSampleGet == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmSampleGet = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGpmSampleGet);

                /* "cuda/bindings/_internal/_nvml.pyx":2710
 *         global __nvmlGpmSampleGet
 *         __nvmlGpmSampleGet = dlsym(RTLD_DEFAULT, 'nvmlGpmSampleGet')
 *         if __nvmlGpmSampleGet == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmSampleGet == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2711
 *         __nvmlGpmSampleGet = dlsym(RTLD_DEFAULT, 'nvmlGpmSampleGet')
 *         if __nvmlGpmSampleGet == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpmSampleGet = dlsym(handle, 'nvmlGpmSampleGet')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2712
 *         if __nvmlGpmSampleGet == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGpmSampleGet = dlsym(handle, 'nvmlGpmSampleGet')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2712, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2711
 *         __nvmlGpmSampleGet = dlsym(RTLD_DEFAULT, 'nvmlGpmSampleGet')
 *         if __nvmlGpmSampleGet == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpmSampleGet = dlsym(handle, 'nvmlGpmSampleGet')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2713
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGpmSampleGet = dlsym(handle, 'nvmlGpmSampleGet')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGpmMigSampleGet
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmSampleGet = dlsym(__pyx_v_handle, __pyx_k_nvmlGpmSampleGet);

                  /* "cuda/bindings/_internal/_nvml.pyx":2710
 *         global __nvmlGpmSampleGet
 *         __nvmlGpmSampleGet = dlsym(RTLD_DEFAULT, 'nvmlGpmSampleGet')
 *         if __nvmlGpmSampleGet == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2716
 * 
 *         global __nvmlGpmMigSampleGet
 *         __nvmlGpmMigSampleGet = dlsym(RTLD_DEFAULT, 'nvmlGpmMigSampleGet')             # <<<<<<<<<<<<<<
 *         if __nvmlGpmMigSampleGet == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmMigSampleGet = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGpmMigSampleGet);

                /* "cuda/bindings/_internal/_nvml.pyx":2717
 *         global __nvmlGpmMigSampleGet
 *         __nvmlGpmMigSampleGet = dlsym(RTLD_DEFAULT, 'nvmlGpmMigSampleGet')
 *         if __nvmlGpmMigSampleGet == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmMigSampleGet == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2718
 *         __nvmlGpmMigSampleGet = dlsym(RTLD_DEFAULT, 'nvmlGpmMigSampleGet')
 *         if __nvmlGpmMigSampleGet == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpmMigSampleGet = dlsym(handle, 'nvmlGpmMigSampleGet')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2719
 *         if __nvmlGpmMigSampleGet == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGpmMigSampleGet = dlsym(handle, 'nvmlGpmMigSampleGet')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2719, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2718
 *         __nvmlGpmMigSampleGet = dlsym(RTLD_DEFAULT, 'nvmlGpmMigSampleGet')
 *         if __nvmlGpmMigSampleGet == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpmMigSampleGet = dlsym(handle, 'nvmlGpmMigSampleGet')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2720
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGpmMigSampleGet = dlsym(handle, 'nvmlGpmMigSampleGet')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGpmQueryDeviceSupport
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmMigSampleGet = dlsym(__pyx_v_handle, __pyx_k_nvmlGpmMigSampleGet);

                  /* "cuda/bindings/_internal/_nvml.pyx":2717
 *         global __nvmlGpmMigSampleGet
 *         __nvmlGpmMigSampleGet = dlsym(RTLD_DEFAULT, 'nvmlGpmMigSampleGet')
 *         if __nvmlGpmMigSampleGet == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2723
 * 
 *         global __nvmlGpmQueryDeviceSupport
 *         __nvmlGpmQueryDeviceSupport = dlsym(RTLD_DEFAULT, 'nvmlGpmQueryDeviceSupport')             # <<<<<<<<<<<<<<
 *         if __nvmlGpmQueryDeviceSupport == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmQueryDeviceSupport = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGpmQueryDeviceSupport);

                /* "cuda/bindings/_internal/_nvml.pyx":2724
 *         global __nvmlGpmQueryDeviceSupport
 *         __nvmlGpmQueryDeviceSupport = dlsym(RTLD_DEFAULT, 'nvmlGpmQueryDeviceSupport')
 *         if __nvmlGpmQueryDeviceSupport == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmQueryDeviceSupport == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2725
 *         __nvmlGpmQueryDeviceSupport = dlsym(RTLD_DEFAULT, 'nvmlGpmQueryDeviceSupport')
 *         if __nvmlGpmQueryDeviceSupport == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpmQueryDeviceSupport = dlsym(handle, 'nvmlGpmQueryDeviceSupport')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2726
 *         if __nvmlGpmQueryDeviceSupport == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGpmQueryDeviceSupport = dlsym(handle, 'nvmlGpmQueryDeviceSupport')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2726, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2725
 *         __nvmlGpmQueryDeviceSupport = dlsym(RTLD_DEFAULT, 'nvmlGpmQueryDeviceSupport')
 *         if __nvmlGpmQueryDeviceSupport == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpmQueryDeviceSupport = dlsym(handle, 'nvmlGpmQueryDeviceSupport')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2727
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGpmQueryDeviceSupport = dlsym(handle, 'nvmlGpmQueryDeviceSupport')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGpmQueryIfStreamingEnabled
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmQueryDeviceSupport = dlsym(__pyx_v_handle, __pyx_k_nvmlGpmQueryDeviceSupport);

                  /* "cuda/bindings/_internal/_nvml.pyx":2724
 *         global __nvmlGpmQueryDeviceSupport
 *         __nvmlGpmQueryDeviceSupport = dlsym(RTLD_DEFAULT, 'nvmlGpmQueryDeviceSupport')
 *         if __nvmlGpmQueryDeviceSupport == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2730
 * 
 *         global __nvmlGpmQueryIfStreamingEnabled
 *         __nvmlGpmQueryIfStreamingEnabled = dlsym(RTLD_DEFAULT, 'nvmlGpmQueryIfStreamingEnabled')             # <<<<<<<<<<<<<<
 *         if __nvmlGpmQueryIfStreamingEnabled == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmQueryIfStreamingEnabled = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGpmQueryIfStreamingEnabled);

                /* "cuda/bindings/_internal/_nvml.pyx":2731
 *         global __nvmlGpmQueryIfStreamingEnabled
 *         __nvmlGpmQueryIfStreamingEnabled = dlsym(RTLD_DEFAULT, 'nvmlGpmQueryIfStreamingEnabled')
 *         if __nvmlGpmQueryIfStreamingEnabled == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmQueryIfStreamingEnabled == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2732
 *         __nvmlGpmQueryIfStreamingEnabled = dlsym(RTLD_DEFAULT, 'nvmlGpmQueryIfStreamingEnabled')
 *         if __nvmlGpmQueryIfStreamingEnabled == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpmQueryIfStreamingEnabled = dlsym(handle, 'nvmlGpmQueryIfStreamingEnabled')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2733
 *         if __nvmlGpmQueryIfStreamingEnabled == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGpmQueryIfStreamingEnabled = dlsym(handle, 'nvmlGpmQueryIfStreamingEnabled')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2733, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2732
 *         __nvmlGpmQueryIfStreamingEnabled = dlsym(RTLD_DEFAULT, 'nvmlGpmQueryIfStreamingEnabled')
 *         if __nvmlGpmQueryIfStreamingEnabled == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpmQueryIfStreamingEnabled = dlsym(handle, 'nvmlGpmQueryIfStreamingEnabled')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2734
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGpmQueryIfStreamingEnabled = dlsym(handle, 'nvmlGpmQueryIfStreamingEnabled')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlGpmSetStreamingEnabled
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmQueryIfStreamingEnabled = dlsym(__pyx_v_handle, __pyx_k_nvmlGpmQueryIfStreamingEnabled);

                  /* "cuda/bindings/_internal/_nvml.pyx":2731
 *         global __nvmlGpmQueryIfStreamingEnabled
 *         __nvmlGpmQueryIfStreamingEnabled = dlsym(RTLD_DEFAULT, 'nvmlGpmQueryIfStreamingEnabled')
 *         if __nvmlGpmQueryIfStreamingEnabled == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2737
 * 
 *         global __nvmlGpmSetStreamingEnabled
 *         __nvmlGpmSetStreamingEnabled = dlsym(RTLD_DEFAULT, 'nvmlGpmSetStreamingEnabled')             # <<<<<<<<<<<<<<
 *         if __nvmlGpmSetStreamingEnabled == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmSetStreamingEnabled = dlsym(RTLD_DEFAULT, __pyx_k_nvmlGpmSetStreamingEnabled);

                /* "cuda/bindings/_internal/_nvml.pyx":2738
 *         global __nvmlGpmSetStreamingEnabled
 *         __nvmlGpmSetStreamingEnabled = dlsym(RTLD_DEFAULT, 'nvmlGpmSetStreamingEnabled')
 *         if __nvmlGpmSetStreamingEnabled == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmSetStreamingEnabled == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2739
 *         __nvmlGpmSetStreamingEnabled = dlsym(RTLD_DEFAULT, 'nvmlGpmSetStreamingEnabled')
 *         if __nvmlGpmSetStreamingEnabled == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpmSetStreamingEnabled = dlsym(handle, 'nvmlGpmSetStreamingEnabled')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2740
 *         if __nvmlGpmSetStreamingEnabled == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlGpmSetStreamingEnabled = dlsym(handle, 'nvmlGpmSetStreamingEnabled')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2740, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2739
 *         __nvmlGpmSetStreamingEnabled = dlsym(RTLD_DEFAULT, 'nvmlGpmSetStreamingEnabled')
 *         if __nvmlGpmSetStreamingEnabled == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlGpmSetStreamingEnabled = dlsym(handle, 'nvmlGpmSetStreamingEnabled')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2741
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlGpmSetStreamingEnabled = dlsym(handle, 'nvmlGpmSetStreamingEnabled')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetCapabilities
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmSetStreamingEnabled = dlsym(__pyx_v_handle, __pyx_k_nvmlGpmSetStreamingEnabled);

                  /* "cuda/bindings/_internal/_nvml.pyx":2738
 *         global __nvmlGpmSetStreamingEnabled
 *         __nvmlGpmSetStreamingEnabled = dlsym(RTLD_DEFAULT, 'nvmlGpmSetStreamingEnabled')
 *         if __nvmlGpmSetStreamingEnabled == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2744
 * 
 *         global __nvmlDeviceGetCapabilities
 *         __nvmlDeviceGetCapabilities = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCapabilities')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetCapabilities == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCapabilities = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetCapabilities);

                /* "cuda/bindings/_internal/_nvml.pyx":2745
 *         global __nvmlDeviceGetCapabilities
 *         __nvmlDeviceGetCapabilities = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCapabilities')
 *         if __nvmlDeviceGetCapabilities == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCapabilities == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2746
 *         __nvmlDeviceGetCapabilities = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCapabilities')
 *         if __nvmlDeviceGetCapabilities == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetCapabilities = dlsym(handle, 'nvmlDeviceGetCapabilities')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2747
 *         if __nvmlDeviceGetCapabilities == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetCapabilities = dlsym(handle, 'nvmlDeviceGetCapabilities')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2747, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2746
 *         __nvmlDeviceGetCapabilities = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCapabilities')
 *         if __nvmlDeviceGetCapabilities == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetCapabilities = dlsym(handle, 'nvmlDeviceGetCapabilities')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2748
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetCapabilities = dlsym(handle, 'nvmlDeviceGetCapabilities')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCapabilities = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetCapabilities);

                  /* "cuda/bindings/_internal/_nvml.pyx":2745
 *         global __nvmlDeviceGetCapabilities
 *         __nvmlDeviceGetCapabilities = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetCapabilities')
 *         if __nvmlDeviceGetCapabilities == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2751
 * 
 *         global __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles
 *         __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles = dlsym(RTLD_DEFAULT, 'nvmlDeviceWorkloadPowerProfileClearRequestedProfiles')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceWorkloadPowerProfileClearRequestedProfiles = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceWorkloadPowerProfileCl);

                /* "cuda/bindings/_internal/_nvml.pyx":2752
 *         global __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles
 *         __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles = dlsym(RTLD_DEFAULT, 'nvmlDeviceWorkloadPowerProfileClearRequestedProfiles')
 *         if __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceWorkloadPowerProfileClearRequestedProfiles == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2753
 *         __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles = dlsym(RTLD_DEFAULT, 'nvmlDeviceWorkloadPowerProfileClearRequestedProfiles')
 *         if __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles = dlsym(handle, 'nvmlDeviceWorkloadPowerProfileClearRequestedProfiles')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2754
 *         if __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles = dlsym(handle, 'nvmlDeviceWorkloadPowerProfileClearRequestedProfiles')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2754, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2753
 *         __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles = dlsym(RTLD_DEFAULT, 'nvmlDeviceWorkloadPowerProfileClearRequestedProfiles')
 *         if __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles = dlsym(handle, 'nvmlDeviceWorkloadPowerProfileClearRequestedProfiles')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2755
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles = dlsym(handle, 'nvmlDeviceWorkloadPowerProfileClearRequestedProfiles')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDevicePowerSmoothingActivatePresetProfile
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceWorkloadPowerProfileClearRequestedProfiles = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceWorkloadPowerProfileCl);

                  /* "cuda/bindings/_internal/_nvml.pyx":2752
 *         global __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles
 *         __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles = dlsym(RTLD_DEFAULT, 'nvmlDeviceWorkloadPowerProfileClearRequestedProfiles')
 *         if __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2758
 * 
 *         global __nvmlDevicePowerSmoothingActivatePresetProfile
 *         __nvmlDevicePowerSmoothingActivatePresetProfile = dlsym(RTLD_DEFAULT, 'nvmlDevicePowerSmoothingActivatePresetProfile')             # <<<<<<<<<<<<<<
 *         if __nvmlDevicePowerSmoothingActivatePresetProfile == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDevicePowerSmoothingActivatePresetProfile = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDevicePowerSmoothingActivate);

                /* "cuda/bindings/_internal/_nvml.pyx":2759
 *         global __nvmlDevicePowerSmoothingActivatePresetProfile
 *         __nvmlDevicePowerSmoothingActivatePresetProfile = dlsym(RTLD_DEFAULT, 'nvmlDevicePowerSmoothingActivatePresetProfile')
 *         if __nvmlDevicePowerSmoothingActivatePresetProfile == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDevicePowerSmoothingActivatePresetProfile == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2760
 *         __nvmlDevicePowerSmoothingActivatePresetProfile = dlsym(RTLD_DEFAULT, 'nvmlDevicePowerSmoothingActivatePresetProfile')
 *         if __nvmlDevicePowerSmoothingActivatePresetProfile == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDevicePowerSmoothingActivatePresetProfile = dlsym(handle, 'nvmlDevicePowerSmoothingActivatePresetProfile')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2761
 *         if __nvmlDevicePowerSmoothingActivatePresetProfile == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDevicePowerSmoothingActivatePresetProfile = dlsym(handle, 'nvmlDevicePowerSmoothingActivatePresetProfile')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2761, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2760
 *         __nvmlDevicePowerSmoothingActivatePresetProfile = dlsym(RTLD_DEFAULT, 'nvmlDevicePowerSmoothingActivatePresetProfile')
 *         if __nvmlDevicePowerSmoothingActivatePresetProfile == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDevicePowerSmoothingActivatePresetProfile = dlsym(handle, 'nvmlDevicePowerSmoothingActivatePresetProfile')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2762
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDevicePowerSmoothingActivatePresetProfile = dlsym(handle, 'nvmlDevicePowerSmoothingActivatePresetProfile')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDevicePowerSmoothingUpdatePresetProfileParam
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDevicePowerSmoothingActivatePresetProfile = dlsym(__pyx_v_handle, __pyx_k_nvmlDevicePowerSmoothingActivate);

                  /* "cuda/bindings/_internal/_nvml.pyx":2759
 *         global __nvmlDevicePowerSmoothingActivatePresetProfile
 *         __nvmlDevicePowerSmoothingActivatePresetProfile = dlsym(RTLD_DEFAULT, 'nvmlDevicePowerSmoothingActivatePresetProfile')
 *         if __nvmlDevicePowerSmoothingActivatePresetProfile == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2765
 * 
 *         global __nvmlDevicePowerSmoothingUpdatePresetProfileParam
 *         __nvmlDevicePowerSmoothingUpdatePresetProfileParam = dlsym(RTLD_DEFAULT, 'nvmlDevicePowerSmoothingUpdatePresetProfileParam')             # <<<<<<<<<<<<<<
 *         if __nvmlDevicePowerSmoothingUpdatePresetProfileParam == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDevicePowerSmoothingUpdatePresetProfileParam = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDevicePowerSmoothingUpdatePr);

                /* "cuda/bindings/_internal/_nvml.pyx":2766
 *         global __nvmlDevicePowerSmoothingUpdatePresetProfileParam
 *         __nvmlDevicePowerSmoothingUpdatePresetProfileParam = dlsym(RTLD_DEFAULT, 'nvmlDevicePowerSmoothingUpdatePresetProfileParam')
 *         if __nvmlDevicePowerSmoothingUpdatePresetProfileParam == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDevicePowerSmoothingUpdatePresetProfileParam == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2767
 *         __nvmlDevicePowerSmoothingUpdatePresetProfileParam = dlsym(RTLD_DEFAULT, 'nvmlDevicePowerSmoothingUpdatePresetProfileParam')
 *         if __nvmlDevicePowerSmoothingUpdatePresetProfileParam == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDevicePowerSmoothingUpdatePresetProfileParam = dlsym(handle, 'nvmlDevicePowerSmoothingUpdatePresetProfileParam')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2768
 *         if __nvmlDevicePowerSmoothingUpdatePresetProfileParam == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDevicePowerSmoothingUpdatePresetProfileParam = dlsym(handle, 'nvmlDevicePowerSmoothingUpdatePresetProfileParam')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2768, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2767
 *         __nvmlDevicePowerSmoothingUpdatePresetProfileParam = dlsym(RTLD_DEFAULT, 'nvmlDevicePowerSmoothingUpdatePresetProfileParam')
 *         if __nvmlDevicePowerSmoothingUpdatePresetProfileParam == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDevicePowerSmoothingUpdatePresetProfileParam = dlsym(handle, 'nvmlDevicePowerSmoothingUpdatePresetProfileParam')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2769
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDevicePowerSmoothingUpdatePresetProfileParam = dlsym(handle, 'nvmlDevicePowerSmoothingUpdatePresetProfileParam')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDevicePowerSmoothingSetState
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDevicePowerSmoothingUpdatePresetProfileParam = dlsym(__pyx_v_handle, __pyx_k_nvmlDevicePowerSmoothingUpdatePr);

                  /* "cuda/bindings/_internal/_nvml.pyx":2766
 *         global __nvmlDevicePowerSmoothingUpdatePresetProfileParam
 *         __nvmlDevicePowerSmoothingUpdatePresetProfileParam = dlsym(RTLD_DEFAULT, 'nvmlDevicePowerSmoothingUpdatePresetProfileParam')
 *         if __nvmlDevicePowerSmoothingUpdatePresetProfileParam == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2772
 * 
 *         global __nvmlDevicePowerSmoothingSetState
 *         __nvmlDevicePowerSmoothingSetState = dlsym(RTLD_DEFAULT, 'nvmlDevicePowerSmoothingSetState')             # <<<<<<<<<<<<<<
 *         if __nvmlDevicePowerSmoothingSetState == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDevicePowerSmoothingSetState = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDevicePowerSmoothingSetState);

                /* "cuda/bindings/_internal/_nvml.pyx":2773
 *         global __nvmlDevicePowerSmoothingSetState
 *         __nvmlDevicePowerSmoothingSetState = dlsym(RTLD_DEFAULT, 'nvmlDevicePowerSmoothingSetState')
 *         if __nvmlDevicePowerSmoothingSetState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDevicePowerSmoothingSetState == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2774
 *         __nvmlDevicePowerSmoothingSetState = dlsym(RTLD_DEFAULT, 'nvmlDevicePowerSmoothingSetState')
 *         if __nvmlDevicePowerSmoothingSetState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDevicePowerSmoothingSetState = dlsym(handle, 'nvmlDevicePowerSmoothingSetState')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2775
 *         if __nvmlDevicePowerSmoothingSetState == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDevicePowerSmoothingSetState = dlsym(handle, 'nvmlDevicePowerSmoothingSetState')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2775, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2774
 *         __nvmlDevicePowerSmoothingSetState = dlsym(RTLD_DEFAULT, 'nvmlDevicePowerSmoothingSetState')
 *         if __nvmlDevicePowerSmoothingSetState == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDevicePowerSmoothingSetState = dlsym(handle, 'nvmlDevicePowerSmoothingSetState')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2776
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDevicePowerSmoothingSetState = dlsym(handle, 'nvmlDevicePowerSmoothingSetState')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetAddressingMode
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDevicePowerSmoothingSetState = dlsym(__pyx_v_handle, __pyx_k_nvmlDevicePowerSmoothingSetState);

                  /* "cuda/bindings/_internal/_nvml.pyx":2773
 *         global __nvmlDevicePowerSmoothingSetState
 *         __nvmlDevicePowerSmoothingSetState = dlsym(RTLD_DEFAULT, 'nvmlDevicePowerSmoothingSetState')
 *         if __nvmlDevicePowerSmoothingSetState == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2779
 * 
 *         global __nvmlDeviceGetAddressingMode
 *         __nvmlDeviceGetAddressingMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAddressingMode')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetAddressingMode == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAddressingMode = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetAddressingMode);

                /* "cuda/bindings/_internal/_nvml.pyx":2780
 *         global __nvmlDeviceGetAddressingMode
 *         __nvmlDeviceGetAddressingMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAddressingMode')
 *         if __nvmlDeviceGetAddressingMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAddressingMode == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2781
 *         __nvmlDeviceGetAddressingMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAddressingMode')
 *         if __nvmlDeviceGetAddressingMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetAddressingMode = dlsym(handle, 'nvmlDeviceGetAddressingMode')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2782
 *         if __nvmlDeviceGetAddressingMode == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetAddressingMode = dlsym(handle, 'nvmlDeviceGetAddressingMode')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2782, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2781
 *         __nvmlDeviceGetAddressingMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAddressingMode')
 *         if __nvmlDeviceGetAddressingMode == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetAddressingMode = dlsym(handle, 'nvmlDeviceGetAddressingMode')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2783
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetAddressingMode = dlsym(handle, 'nvmlDeviceGetAddressingMode')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetRepairStatus
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAddressingMode = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetAddressingMode);

                  /* "cuda/bindings/_internal/_nvml.pyx":2780
 *         global __nvmlDeviceGetAddressingMode
 *         __nvmlDeviceGetAddressingMode = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetAddressingMode')
 *         if __nvmlDeviceGetAddressingMode == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2786
 * 
 *         global __nvmlDeviceGetRepairStatus
 *         __nvmlDeviceGetRepairStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRepairStatus')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetRepairStatus == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRepairStatus = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetRepairStatus);

                /* "cuda/bindings/_internal/_nvml.pyx":2787
 *         global __nvmlDeviceGetRepairStatus
 *         __nvmlDeviceGetRepairStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRepairStatus')
 *         if __nvmlDeviceGetRepairStatus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRepairStatus == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2788
 *         __nvmlDeviceGetRepairStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRepairStatus')
 *         if __nvmlDeviceGetRepairStatus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetRepairStatus = dlsym(handle, 'nvmlDeviceGetRepairStatus')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2789
 *         if __nvmlDeviceGetRepairStatus == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetRepairStatus = dlsym(handle, 'nvmlDeviceGetRepairStatus')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2789, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2788
 *         __nvmlDeviceGetRepairStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRepairStatus')
 *         if __nvmlDeviceGetRepairStatus == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetRepairStatus = dlsym(handle, 'nvmlDeviceGetRepairStatus')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2790
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetRepairStatus = dlsym(handle, 'nvmlDeviceGetRepairStatus')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetPowerMizerMode_v1
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRepairStatus = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetRepairStatus);

                  /* "cuda/bindings/_internal/_nvml.pyx":2787
 *         global __nvmlDeviceGetRepairStatus
 *         __nvmlDeviceGetRepairStatus = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetRepairStatus')
 *         if __nvmlDeviceGetRepairStatus == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2793
 * 
 *         global __nvmlDeviceGetPowerMizerMode_v1
 *         __nvmlDeviceGetPowerMizerMode_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerMizerMode_v1')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetPowerMizerMode_v1 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerMizerMode_v1 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetPowerMizerMode_v1);

                /* "cuda/bindings/_internal/_nvml.pyx":2794
 *         global __nvmlDeviceGetPowerMizerMode_v1
 *         __nvmlDeviceGetPowerMizerMode_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerMizerMode_v1')
 *         if __nvmlDeviceGetPowerMizerMode_v1 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerMizerMode_v1 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2795
 *         __nvmlDeviceGetPowerMizerMode_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerMizerMode_v1')
 *         if __nvmlDeviceGetPowerMizerMode_v1 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPowerMizerMode_v1 = dlsym(handle, 'nvmlDeviceGetPowerMizerMode_v1')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2796
 *         if __nvmlDeviceGetPowerMizerMode_v1 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetPowerMizerMode_v1 = dlsym(handle, 'nvmlDeviceGetPowerMizerMode_v1')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2796, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2795
 *         __nvmlDeviceGetPowerMizerMode_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerMizerMode_v1')
 *         if __nvmlDeviceGetPowerMizerMode_v1 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPowerMizerMode_v1 = dlsym(handle, 'nvmlDeviceGetPowerMizerMode_v1')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2797
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetPowerMizerMode_v1 = dlsym(handle, 'nvmlDeviceGetPowerMizerMode_v1')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetPowerMizerMode_v1
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerMizerMode_v1 = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetPowerMizerMode_v1);

                  /* "cuda/bindings/_internal/_nvml.pyx":2794
 *         global __nvmlDeviceGetPowerMizerMode_v1
 *         __nvmlDeviceGetPowerMizerMode_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPowerMizerMode_v1')
 *         if __nvmlDeviceGetPowerMizerMode_v1 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2800
 * 
 *         global __nvmlDeviceSetPowerMizerMode_v1
 *         __nvmlDeviceSetPowerMizerMode_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetPowerMizerMode_v1')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetPowerMizerMode_v1 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPowerMizerMode_v1 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetPowerMizerMode_v1);

                /* "cuda/bindings/_internal/_nvml.pyx":2801
 *         global __nvmlDeviceSetPowerMizerMode_v1
 *         __nvmlDeviceSetPowerMizerMode_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetPowerMizerMode_v1')
 *         if __nvmlDeviceSetPowerMizerMode_v1 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPowerMizerMode_v1 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2802
 *         __nvmlDeviceSetPowerMizerMode_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetPowerMizerMode_v1')
 *         if __nvmlDeviceSetPowerMizerMode_v1 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetPowerMizerMode_v1 = dlsym(handle, 'nvmlDeviceSetPowerMizerMode_v1')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2803
 *         if __nvmlDeviceSetPowerMizerMode_v1 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetPowerMizerMode_v1 = dlsym(handle, 'nvmlDeviceSetPowerMizerMode_v1')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2803, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2802
 *         __nvmlDeviceSetPowerMizerMode_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetPowerMizerMode_v1')
 *         if __nvmlDeviceSetPowerMizerMode_v1 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetPowerMizerMode_v1 = dlsym(handle, 'nvmlDeviceSetPowerMizerMode_v1')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2804
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetPowerMizerMode_v1 = dlsym(handle, 'nvmlDeviceSetPowerMizerMode_v1')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetPdi
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPowerMizerMode_v1 = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetPowerMizerMode_v1);

                  /* "cuda/bindings/_internal/_nvml.pyx":2801
 *         global __nvmlDeviceSetPowerMizerMode_v1
 *         __nvmlDeviceSetPowerMizerMode_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetPowerMizerMode_v1')
 *         if __nvmlDeviceSetPowerMizerMode_v1 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2807
 * 
 *         global __nvmlDeviceGetPdi
 *         __nvmlDeviceGetPdi = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPdi')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetPdi == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPdi = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetPdi);

                /* "cuda/bindings/_internal/_nvml.pyx":2808
 *         global __nvmlDeviceGetPdi
 *         __nvmlDeviceGetPdi = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPdi')
 *         if __nvmlDeviceGetPdi == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPdi == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2809
 *         __nvmlDeviceGetPdi = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPdi')
 *         if __nvmlDeviceGetPdi == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPdi = dlsym(handle, 'nvmlDeviceGetPdi')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2810
 *         if __nvmlDeviceGetPdi == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetPdi = dlsym(handle, 'nvmlDeviceGetPdi')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2810, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2809
 *         __nvmlDeviceGetPdi = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPdi')
 *         if __nvmlDeviceGetPdi == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetPdi = dlsym(handle, 'nvmlDeviceGetPdi')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2811
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetPdi = dlsym(handle, 'nvmlDeviceGetPdi')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceSetHostname_v1
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPdi = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetPdi);

                  /* "cuda/bindings/_internal/_nvml.pyx":2808
 *         global __nvmlDeviceGetPdi
 *         __nvmlDeviceGetPdi = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetPdi')
 *         if __nvmlDeviceGetPdi == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2814
 * 
 *         global __nvmlDeviceSetHostname_v1
 *         __nvmlDeviceSetHostname_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetHostname_v1')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceSetHostname_v1 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetHostname_v1 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceSetHostname_v1);

                /* "cuda/bindings/_internal/_nvml.pyx":2815
 *         global __nvmlDeviceSetHostname_v1
 *         __nvmlDeviceSetHostname_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetHostname_v1')
 *         if __nvmlDeviceSetHostname_v1 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetHostname_v1 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2816
 *         __nvmlDeviceSetHostname_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetHostname_v1')
 *         if __nvmlDeviceSetHostname_v1 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetHostname_v1 = dlsym(handle, 'nvmlDeviceSetHostname_v1')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2817
 *         if __nvmlDeviceSetHostname_v1 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceSetHostname_v1 = dlsym(handle, 'nvmlDeviceSetHostname_v1')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2817, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2816
 *         __nvmlDeviceSetHostname_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetHostname_v1')
 *         if __nvmlDeviceSetHostname_v1 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceSetHostname_v1 = dlsym(handle, 'nvmlDeviceSetHostname_v1')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2818
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceSetHostname_v1 = dlsym(handle, 'nvmlDeviceSetHostname_v1')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetHostname_v1
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetHostname_v1 = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceSetHostname_v1);

                  /* "cuda/bindings/_internal/_nvml.pyx":2815
 *         global __nvmlDeviceSetHostname_v1
 *         __nvmlDeviceSetHostname_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceSetHostname_v1')
 *         if __nvmlDeviceSetHostname_v1 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2821
 * 
 *         global __nvmlDeviceGetHostname_v1
 *         __nvmlDeviceGetHostname_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHostname_v1')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetHostname_v1 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHostname_v1 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetHostname_v1);

                /* "cuda/bindings/_internal/_nvml.pyx":2822
 *         global __nvmlDeviceGetHostname_v1
 *         __nvmlDeviceGetHostname_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHostname_v1')
 *         if __nvmlDeviceGetHostname_v1 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHostname_v1 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2823
 *         __nvmlDeviceGetHostname_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHostname_v1')
 *         if __nvmlDeviceGetHostname_v1 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetHostname_v1 = dlsym(handle, 'nvmlDeviceGetHostname_v1')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2824
 *         if __nvmlDeviceGetHostname_v1 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetHostname_v1 = dlsym(handle, 'nvmlDeviceGetHostname_v1')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2824, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2823
 *         __nvmlDeviceGetHostname_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHostname_v1')
 *         if __nvmlDeviceGetHostname_v1 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetHostname_v1 = dlsym(handle, 'nvmlDeviceGetHostname_v1')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2825
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetHostname_v1 = dlsym(handle, 'nvmlDeviceGetHostname_v1')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetNvLinkInfo
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHostname_v1 = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetHostname_v1);

                  /* "cuda/bindings/_internal/_nvml.pyx":2822
 *         global __nvmlDeviceGetHostname_v1
 *         __nvmlDeviceGetHostname_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetHostname_v1')
 *         if __nvmlDeviceGetHostname_v1 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2828
 * 
 *         global __nvmlDeviceGetNvLinkInfo
 *         __nvmlDeviceGetNvLinkInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkInfo')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetNvLinkInfo == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkInfo = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetNvLinkInfo);

                /* "cuda/bindings/_internal/_nvml.pyx":2829
 *         global __nvmlDeviceGetNvLinkInfo
 *         __nvmlDeviceGetNvLinkInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkInfo')
 *         if __nvmlDeviceGetNvLinkInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkInfo == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2830
 *         __nvmlDeviceGetNvLinkInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkInfo')
 *         if __nvmlDeviceGetNvLinkInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetNvLinkInfo = dlsym(handle, 'nvmlDeviceGetNvLinkInfo')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2831
 *         if __nvmlDeviceGetNvLinkInfo == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetNvLinkInfo = dlsym(handle, 'nvmlDeviceGetNvLinkInfo')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2831, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2830
 *         __nvmlDeviceGetNvLinkInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkInfo')
 *         if __nvmlDeviceGetNvLinkInfo == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetNvLinkInfo = dlsym(handle, 'nvmlDeviceGetNvLinkInfo')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2832
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetNvLinkInfo = dlsym(handle, 'nvmlDeviceGetNvLinkInfo')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceReadWritePRM_v1
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkInfo = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetNvLinkInfo);

                  /* "cuda/bindings/_internal/_nvml.pyx":2829
 *         global __nvmlDeviceGetNvLinkInfo
 *         __nvmlDeviceGetNvLinkInfo = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetNvLinkInfo')
 *         if __nvmlDeviceGetNvLinkInfo == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2835
 * 
 *         global __nvmlDeviceReadWritePRM_v1
 *         __nvmlDeviceReadWritePRM_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceReadWritePRM_v1')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceReadWritePRM_v1 == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceReadWritePRM_v1 = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceReadWritePRM_v1);

                /* "cuda/bindings/_internal/_nvml.pyx":2836
 *         global __nvmlDeviceReadWritePRM_v1
 *         __nvmlDeviceReadWritePRM_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceReadWritePRM_v1')
 *         if __nvmlDeviceReadWritePRM_v1 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceReadWritePRM_v1 == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2837
 *         __nvmlDeviceReadWritePRM_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceReadWritePRM_v1')
 *         if __nvmlDeviceReadWritePRM_v1 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceReadWritePRM_v1 = dlsym(handle, 'nvmlDeviceReadWritePRM_v1')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2838
 *         if __nvmlDeviceReadWritePRM_v1 == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceReadWritePRM_v1 = dlsym(handle, 'nvmlDeviceReadWritePRM_v1')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2838, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2837
 *         __nvmlDeviceReadWritePRM_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceReadWritePRM_v1')
 *         if __nvmlDeviceReadWritePRM_v1 == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceReadWritePRM_v1 = dlsym(handle, 'nvmlDeviceReadWritePRM_v1')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2839
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceReadWritePRM_v1 = dlsym(handle, 'nvmlDeviceReadWritePRM_v1')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetGpuInstanceProfileInfoByIdV
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceReadWritePRM_v1 = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceReadWritePRM_v1);

                  /* "cuda/bindings/_internal/_nvml.pyx":2836
 *         global __nvmlDeviceReadWritePRM_v1
 *         __nvmlDeviceReadWritePRM_v1 = dlsym(RTLD_DEFAULT, 'nvmlDeviceReadWritePRM_v1')
 *         if __nvmlDeviceReadWritePRM_v1 == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2842
 * 
 *         global __nvmlDeviceGetGpuInstanceProfileInfoByIdV
 *         __nvmlDeviceGetGpuInstanceProfileInfoByIdV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceProfileInfoByIdV')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetGpuInstanceProfileInfoByIdV == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceProfileInfoByIdV = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetGpuInstanceProfileI_2);

                /* "cuda/bindings/_internal/_nvml.pyx":2843
 *         global __nvmlDeviceGetGpuInstanceProfileInfoByIdV
 *         __nvmlDeviceGetGpuInstanceProfileInfoByIdV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceProfileInfoByIdV')
 *         if __nvmlDeviceGetGpuInstanceProfileInfoByIdV == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceProfileInfoByIdV == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2844
 *         __nvmlDeviceGetGpuInstanceProfileInfoByIdV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceProfileInfoByIdV')
 *         if __nvmlDeviceGetGpuInstanceProfileInfoByIdV == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuInstanceProfileInfoByIdV = dlsym(handle, 'nvmlDeviceGetGpuInstanceProfileInfoByIdV')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2845
 *         if __nvmlDeviceGetGpuInstanceProfileInfoByIdV == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetGpuInstanceProfileInfoByIdV = dlsym(handle, 'nvmlDeviceGetGpuInstanceProfileInfoByIdV')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2845, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2844
 *         __nvmlDeviceGetGpuInstanceProfileInfoByIdV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceProfileInfoByIdV')
 *         if __nvmlDeviceGetGpuInstanceProfileInfoByIdV == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuInstanceProfileInfoByIdV = dlsym(handle, 'nvmlDeviceGetGpuInstanceProfileInfoByIdV')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2846
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetGpuInstanceProfileInfoByIdV = dlsym(handle, 'nvmlDeviceGetGpuInstanceProfileInfoByIdV')             # <<<<<<<<<<<<<<
 * 
 *         global __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceProfileInfoByIdV = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetGpuInstanceProfileI_2);

                  /* "cuda/bindings/_internal/_nvml.pyx":2843
 *         global __nvmlDeviceGetGpuInstanceProfileInfoByIdV
 *         __nvmlDeviceGetGpuInstanceProfileInfoByIdV = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetGpuInstanceProfileInfoByIdV')
 *         if __nvmlDeviceGetGpuInstanceProfileInfoByIdV == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2849
 * 
 *         global __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts
 *         __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts')             # <<<<<<<<<<<<<<
 *         if __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts == NULL:
 *             if handle == NULL:
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts = dlsym(RTLD_DEFAULT, __pyx_k_nvmlDeviceGetSramUniqueUncorrect);

                /* "cuda/bindings/_internal/_nvml.pyx":2850
 *         global __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts
 *         __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts')
 *         if __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                __pyx_t_9 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts == NULL);
                if (__pyx_t_9) {

                  /* "cuda/bindings/_internal/_nvml.pyx":2851
 *         __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts')
 *         if __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts = dlsym(handle, 'nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts')
*/
                  __pyx_t_9 = (__pyx_v_handle == NULL);
                  if (__pyx_t_9) {

                    /* "cuda/bindings/_internal/_nvml.pyx":2852
 *         if __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts == NULL:
 *             if handle == NULL:
 *                 handle = load_library()             # <<<<<<<<<<<<<<
 *             __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts = dlsym(handle, 'nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts')
 * 
*/
                    __pyx_t_10 = __pyx_f_4cuda_8bindings_9_internal_5_nvml_load_library(); if (unlikely(__pyx_t_10 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 2852, __pyx_L10_error)
                    __pyx_v_handle = __pyx_t_10;

                    /* "cuda/bindings/_internal/_nvml.pyx":2851
 *         __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts')
 *         if __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts == NULL:
 *             if handle == NULL:             # <<<<<<<<<<<<<<
 *                 handle = load_library()
 *             __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts = dlsym(handle, 'nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts')
*/
                  }

                  /* "cuda/bindings/_internal/_nvml.pyx":2853
 *             if handle == NULL:
 *                 handle = load_library()
 *             __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts = dlsym(handle, 'nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts')             # <<<<<<<<<<<<<<
 * 
 *         __py_nvml_init = True
*/
                  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts = dlsym(__pyx_v_handle, __pyx_k_nvmlDeviceGetSramUniqueUncorrect);

                  /* "cuda/bindings/_internal/_nvml.pyx":2850
 *         global __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts
 *         __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts = dlsym(RTLD_DEFAULT, 'nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts')
 *         if __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts == NULL:             # <<<<<<<<<<<<<<
 *             if handle == NULL:
 *                 handle = load_library()
*/
                }

                /* "cuda/bindings/_internal/_nvml.pyx":2855
 *             __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts = dlsym(handle, 'nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts')
 * 
 *         __py_nvml_init = True             # <<<<<<<<<<<<<<
 *         return 0
 * 
*/
                __pyx_v_4cuda_8bindings_9_internal_5_nvml___py_nvml_init = 1;

                /* "cuda/bindings/_internal/_nvml.pyx":2856
 * 
 *         __py_nvml_init = True
 *         return 0             # <<<<<<<<<<<<<<
 * 
 * 
*/
                __pyx_r = 0;
                goto __pyx_L14_try_return;

                /* "cuda/bindings/_internal/_nvml.pyx":420
 *     cdef void* handle = NULL
 * 
 *     with gil, __symbol_lock:             # <<<<<<<<<<<<<<
 *         # Recheck the flag after obtaining the locks
 *         if __py_nvml_init:
*/
              }
              __pyx_L10_error:;
              __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
              __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
              __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
              /*except:*/ {
                __Pyx_AddTraceback("cuda.bindings._internal._nvml._init_nvml", __pyx_clineno, __pyx_lineno, __pyx_filename);
                if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_4, &__pyx_t_3) < 0) __PYX_ERR(0, 420, __pyx_L12_except_error)
                __Pyx_XGOTREF(__pyx_t_2);
                __Pyx_XGOTREF(__pyx_t_4);
                __Pyx_XGOTREF(__pyx_t_3);
                __pyx_t_11 = PyTuple_Pack(3, __pyx_t_2, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 420, __pyx_L12_except_error)
                __Pyx_GOTREF(__pyx_t_11);
                __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_11, NULL);
                __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
                if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 420, __pyx_L12_except_error)
                __Pyx_GOTREF(__pyx_t_12);
                __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_12);
                __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
                if (__pyx_t_9 < (0)) __PYX_ERR(0, 420, __pyx_L12_except_error)
                __pyx_t_13 = (!__pyx_t_9);
                if (unlikely(__pyx_t_13)) {
                  __Pyx_GIVEREF(__pyx_t_2);
                  __Pyx_GIVEREF(__pyx_t_4);
                  __Pyx_XGIVEREF(__pyx_t_3);
                  __Pyx_ErrRestoreWithState(__pyx_t_2, __pyx_t_4, __pyx_t_3);
                  __pyx_t_2 = 0;  __pyx_t_4 = 0;  __pyx_t_3 = 0; 
                  __PYX_ERR(0, 420, __pyx_L12_except_error)
                }
                __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
                __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
                __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
                goto __pyx_L11_exception_handled;
              }
              __pyx_L12_except_error:;
              __Pyx_XGIVEREF(__pyx_t_6);
              __Pyx_XGIVEREF(__pyx_t_7);
              __Pyx_XGIVEREF(__pyx_t_8);
              __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
              goto __pyx_L4_error;
              __pyx_L14_try_return:;
              __Pyx_XGIVEREF(__pyx_t_6);
              __Pyx_XGIVEREF(__pyx_t_7);
              __Pyx_XGIVEREF(__pyx_t_8);
              __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
              goto __pyx_L7_return;
              __pyx_L11_exception_handled:;
              __Pyx_XGIVEREF(__pyx_t_6);
              __Pyx_XGIVEREF(__pyx_t_7);
              __Pyx_XGIVEREF(__pyx_t_8);
              __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
            }
          }
          /*finally:*/ {
            /*normal exit:*/{
              if (__pyx_t_1) {
                __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_mstate_global->__pyx_tuple[0], NULL);
                __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 420, __pyx_L4_error)
                __Pyx_GOTREF(__pyx_t_8);
                __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
              }
              goto __pyx_L9;
            }
            __pyx_L7_return: {
              __pyx_t_14 = __pyx_r;
              if (__pyx_t_1) {
                __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_mstate_global->__pyx_tuple[0], NULL);
                __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 420, __pyx_L4_error)
                __Pyx_GOTREF(__pyx_t_8);
                __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
              }
              __pyx_r = __pyx_t_14;
              goto __pyx_L3_return;
            }
            __pyx_L9:;
          }
          goto __pyx_L714;
          __pyx_L6_error:;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          goto __pyx_L4_error;
          __pyx_L714:;
        }
      }
      /*finally:*/ {
        /*normal exit:*/{
          __Pyx_PyGILState_Release(__pyx_gilstate_save);
          goto __pyx_L5;
        }
        __pyx_L3_return: {
          __Pyx_PyGILState_Release(__pyx_gilstate_save);
          goto __pyx_L0;
        }
        __pyx_L4_error: {
          __Pyx_PyGILState_Release(__pyx_gilstate_save);
          goto __pyx_L1_error;
        }
        __pyx_L5:;
      }
  }

  /* "cuda/bindings/_internal/_nvml.pyx":416
 * 
 * 
 * cdef int _init_nvml() except -1 nogil:             # <<<<<<<<<<<<<<
 *     global __py_nvml_init
 *     cdef void* handle = NULL
*/

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._init_nvml", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":2859
 * 
 * 
 * cdef inline int _check_or_init_nvml() except -1 nogil:             # <<<<<<<<<<<<<<
 *     if __py_nvml_init:
 *         return 0
*/

static CYTHON_INLINE int __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(void) {
  int __pyx_r;
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;

  /* "cuda/bindings/_internal/_nvml.pyx":2860
 * 
 * cdef inline int _check_or_init_nvml() except -1 nogil:
 *     if __py_nvml_init:             # <<<<<<<<<<<<<<
 *         return 0
 * 
*/
  if (__pyx_v_4cuda_8bindings_9_internal_5_nvml___py_nvml_init) {

    /* "cuda/bindings/_internal/_nvml.pyx":2861
 * cdef inline int _check_or_init_nvml() except -1 nogil:
 *     if __py_nvml_init:
 *         return 0             # <<<<<<<<<<<<<<
 * 
 *     return _init_nvml()
*/
    __pyx_r = 0;
    goto __pyx_L0;

    /* "cuda/bindings/_internal/_nvml.pyx":2860
 * 
 * cdef inline int _check_or_init_nvml() except -1 nogil:
 *     if __py_nvml_init:             # <<<<<<<<<<<<<<
 *         return 0
 * 
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":2863
 *         return 0
 * 
 *     return _init_nvml()             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 2863, __pyx_L1_error)
  __pyx_r = __pyx_t_1;
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":2859
 * 
 * 
 * cdef inline int _check_or_init_nvml() except -1 nogil:             # <<<<<<<<<<<<<<
 *     if __py_nvml_init:
 *         return 0
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._check_or_init_nvml", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":2869
 * 
 * 
 * cpdef dict _inspect_function_pointers():             # <<<<<<<<<<<<<<
 *     global func_ptrs
 *     if func_ptrs is not None:
*/

static PyObject *__pyx_pw_4cuda_8bindings_9_internal_5_nvml_1_inspect_function_pointers(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static PyObject *__pyx_f_4cuda_8bindings_9_internal_5_nvml__inspect_function_pointers(CYTHON_UNUSED int __pyx_skip_dispatch) {
  PyObject *__pyx_v_data = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("_inspect_function_pointers", 0);

  /* "cuda/bindings/_internal/_nvml.pyx":2871
 * cpdef dict _inspect_function_pointers():
 *     global func_ptrs
 *     if func_ptrs is not None:             # <<<<<<<<<<<<<<
 *         return func_ptrs
 * 
*/
  __pyx_t_1 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml_func_ptrs != ((PyObject*)Py_None));
  if (__pyx_t_1) {

    /* "cuda/bindings/_internal/_nvml.pyx":2872
 *     global func_ptrs
 *     if func_ptrs is not None:
 *         return func_ptrs             # <<<<<<<<<<<<<<
 * 
 *     _check_or_init_nvml()
*/
    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_v_4cuda_8bindings_9_internal_5_nvml_func_ptrs);
    __pyx_r = __pyx_v_4cuda_8bindings_9_internal_5_nvml_func_ptrs;
    goto __pyx_L0;

    /* "cuda/bindings/_internal/_nvml.pyx":2871
 * cpdef dict _inspect_function_pointers():
 *     global func_ptrs
 *     if func_ptrs is not None:             # <<<<<<<<<<<<<<
 *         return func_ptrs
 * 
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":2874
 *         return func_ptrs
 * 
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     cdef dict data = {}
 * 
*/
  __pyx_t_2 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 2874, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":2875
 * 
 *     _check_or_init_nvml()
 *     cdef dict data = {}             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlInit_v2
*/
  __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2875, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_data = ((PyObject*)__pyx_t_3);
  __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2878
 * 
 *     global __nvmlInit_v2
 *     data["__nvmlInit_v2"] = <intptr_t>__nvmlInit_v2             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlInitWithFlags
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlInit_v2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2878, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlInit_v2_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2878, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2881
 * 
 *     global __nvmlInitWithFlags
 *     data["__nvmlInitWithFlags"] = <intptr_t>__nvmlInitWithFlags             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlShutdown
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlInitWithFlags)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2881, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlInitWithFlags_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2881, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2884
 * 
 *     global __nvmlShutdown
 *     data["__nvmlShutdown"] = <intptr_t>__nvmlShutdown             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlErrorString
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlShutdown)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2884, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlShutdown_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2884, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2887
 * 
 *     global __nvmlErrorString
 *     data["__nvmlErrorString"] = <intptr_t>__nvmlErrorString             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlSystemGetDriverVersion
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlErrorString)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2887, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlErrorString_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2887, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2890
 * 
 *     global __nvmlSystemGetDriverVersion
 *     data["__nvmlSystemGetDriverVersion"] = <intptr_t>__nvmlSystemGetDriverVersion             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlSystemGetNVMLVersion
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetDriverVersion)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2890, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlSystemGetDriverVersion_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2890, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2893
 * 
 *     global __nvmlSystemGetNVMLVersion
 *     data["__nvmlSystemGetNVMLVersion"] = <intptr_t>__nvmlSystemGetNVMLVersion             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlSystemGetCudaDriverVersion
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetNVMLVersion)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2893, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlSystemGetNVMLVersion_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2893, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2896
 * 
 *     global __nvmlSystemGetCudaDriverVersion
 *     data["__nvmlSystemGetCudaDriverVersion"] = <intptr_t>__nvmlSystemGetCudaDriverVersion             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlSystemGetCudaDriverVersion_v2
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetCudaDriverVersion)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2896, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlSystemGetCudaDriverVersion_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2896, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2899
 * 
 *     global __nvmlSystemGetCudaDriverVersion_v2
 *     data["__nvmlSystemGetCudaDriverVersion_v2"] = <intptr_t>__nvmlSystemGetCudaDriverVersion_v2             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlSystemGetProcessName
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetCudaDriverVersion_v2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2899, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlSystemGetCudaDriverVersion_3, __pyx_t_3) < 0))) __PYX_ERR(0, 2899, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2902
 * 
 *     global __nvmlSystemGetProcessName
 *     data["__nvmlSystemGetProcessName"] = <intptr_t>__nvmlSystemGetProcessName             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlSystemGetHicVersion
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetProcessName)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2902, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlSystemGetProcessName_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2902, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2905
 * 
 *     global __nvmlSystemGetHicVersion
 *     data["__nvmlSystemGetHicVersion"] = <intptr_t>__nvmlSystemGetHicVersion             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlSystemGetTopologyGpuSet
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetHicVersion)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2905, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlSystemGetHicVersion_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2905, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2908
 * 
 *     global __nvmlSystemGetTopologyGpuSet
 *     data["__nvmlSystemGetTopologyGpuSet"] = <intptr_t>__nvmlSystemGetTopologyGpuSet             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlSystemGetDriverBranch
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetTopologyGpuSet)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2908, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlSystemGetTopologyGpuSet_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2908, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2911
 * 
 *     global __nvmlSystemGetDriverBranch
 *     data["__nvmlSystemGetDriverBranch"] = <intptr_t>__nvmlSystemGetDriverBranch             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlUnitGetCount
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetDriverBranch)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2911, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlSystemGetDriverBranch_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2911, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2914
 * 
 *     global __nvmlUnitGetCount
 *     data["__nvmlUnitGetCount"] = <intptr_t>__nvmlUnitGetCount             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlUnitGetHandleByIndex
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetCount)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2914, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlUnitGetCount_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2914, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2917
 * 
 *     global __nvmlUnitGetHandleByIndex
 *     data["__nvmlUnitGetHandleByIndex"] = <intptr_t>__nvmlUnitGetHandleByIndex             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlUnitGetUnitInfo
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetHandleByIndex)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2917, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlUnitGetHandleByIndex_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2917, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2920
 * 
 *     global __nvmlUnitGetUnitInfo
 *     data["__nvmlUnitGetUnitInfo"] = <intptr_t>__nvmlUnitGetUnitInfo             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlUnitGetLedState
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetUnitInfo)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2920, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlUnitGetUnitInfo_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2920, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2923
 * 
 *     global __nvmlUnitGetLedState
 *     data["__nvmlUnitGetLedState"] = <intptr_t>__nvmlUnitGetLedState             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlUnitGetPsuInfo
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetLedState)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2923, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlUnitGetLedState_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2923, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2926
 * 
 *     global __nvmlUnitGetPsuInfo
 *     data["__nvmlUnitGetPsuInfo"] = <intptr_t>__nvmlUnitGetPsuInfo             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlUnitGetTemperature
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetPsuInfo)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2926, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlUnitGetPsuInfo_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2926, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2929
 * 
 *     global __nvmlUnitGetTemperature
 *     data["__nvmlUnitGetTemperature"] = <intptr_t>__nvmlUnitGetTemperature             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlUnitGetFanSpeedInfo
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetTemperature)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2929, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlUnitGetTemperature_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2929, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2932
 * 
 *     global __nvmlUnitGetFanSpeedInfo
 *     data["__nvmlUnitGetFanSpeedInfo"] = <intptr_t>__nvmlUnitGetFanSpeedInfo             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlUnitGetDevices
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetFanSpeedInfo)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2932, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlUnitGetFanSpeedInfo_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2932, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2935
 * 
 *     global __nvmlUnitGetDevices
 *     data["__nvmlUnitGetDevices"] = <intptr_t>__nvmlUnitGetDevices             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetCount_v2
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetDevices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2935, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlUnitGetDevices_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2935, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2938
 * 
 *     global __nvmlDeviceGetCount_v2
 *     data["__nvmlDeviceGetCount_v2"] = <intptr_t>__nvmlDeviceGetCount_v2             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetAttributes_v2
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCount_v2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2938, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetCount_v2_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2938, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2941
 * 
 *     global __nvmlDeviceGetAttributes_v2
 *     data["__nvmlDeviceGetAttributes_v2"] = <intptr_t>__nvmlDeviceGetAttributes_v2             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetHandleByIndex_v2
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAttributes_v2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2941, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetAttributes_v2_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2941, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2944
 * 
 *     global __nvmlDeviceGetHandleByIndex_v2
 *     data["__nvmlDeviceGetHandleByIndex_v2"] = <intptr_t>__nvmlDeviceGetHandleByIndex_v2             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetHandleBySerial
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByIndex_v2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2944, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetHandleByIndex_v2_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2944, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2947
 * 
 *     global __nvmlDeviceGetHandleBySerial
 *     data["__nvmlDeviceGetHandleBySerial"] = <intptr_t>__nvmlDeviceGetHandleBySerial             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetHandleByUUID
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleBySerial)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2947, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetHandleBySerial_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2947, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2950
 * 
 *     global __nvmlDeviceGetHandleByUUID
 *     data["__nvmlDeviceGetHandleByUUID"] = <intptr_t>__nvmlDeviceGetHandleByUUID             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetHandleByUUIDV
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByUUID)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2950, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetHandleByUUID_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2950, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2953
 * 
 *     global __nvmlDeviceGetHandleByUUIDV
 *     data["__nvmlDeviceGetHandleByUUIDV"] = <intptr_t>__nvmlDeviceGetHandleByUUIDV             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetHandleByPciBusId_v2
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByUUIDV)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2953, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetHandleByUUIDV_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2953, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2956
 * 
 *     global __nvmlDeviceGetHandleByPciBusId_v2
 *     data["__nvmlDeviceGetHandleByPciBusId_v2"] = <intptr_t>__nvmlDeviceGetHandleByPciBusId_v2             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetName
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByPciBusId_v2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2956, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetHandleByPciBusId, __pyx_t_3) < 0))) __PYX_ERR(0, 2956, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2959
 * 
 *     global __nvmlDeviceGetName
 *     data["__nvmlDeviceGetName"] = <intptr_t>__nvmlDeviceGetName             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetBrand
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetName)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2959, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetName_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2959, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2962
 * 
 *     global __nvmlDeviceGetBrand
 *     data["__nvmlDeviceGetBrand"] = <intptr_t>__nvmlDeviceGetBrand             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetIndex
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBrand)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2962, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetBrand_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2962, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2965
 * 
 *     global __nvmlDeviceGetIndex
 *     data["__nvmlDeviceGetIndex"] = <intptr_t>__nvmlDeviceGetIndex             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetSerial
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetIndex)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2965, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetIndex_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2965, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2968
 * 
 *     global __nvmlDeviceGetSerial
 *     data["__nvmlDeviceGetSerial"] = <intptr_t>__nvmlDeviceGetSerial             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetModuleId
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSerial)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2968, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetSerial_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2968, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2971
 * 
 *     global __nvmlDeviceGetModuleId
 *     data["__nvmlDeviceGetModuleId"] = <intptr_t>__nvmlDeviceGetModuleId             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetC2cModeInfoV
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetModuleId)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2971, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetModuleId_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2971, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2974
 * 
 *     global __nvmlDeviceGetC2cModeInfoV
 *     data["__nvmlDeviceGetC2cModeInfoV"] = <intptr_t>__nvmlDeviceGetC2cModeInfoV             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetMemoryAffinity
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetC2cModeInfoV)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2974, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetC2cModeInfoV_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2974, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2977
 * 
 *     global __nvmlDeviceGetMemoryAffinity
 *     data["__nvmlDeviceGetMemoryAffinity"] = <intptr_t>__nvmlDeviceGetMemoryAffinity             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetCpuAffinityWithinScope
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryAffinity)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2977, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetMemoryAffinity_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2977, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2980
 * 
 *     global __nvmlDeviceGetCpuAffinityWithinScope
 *     data["__nvmlDeviceGetCpuAffinityWithinScope"] = <intptr_t>__nvmlDeviceGetCpuAffinityWithinScope             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetCpuAffinity
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCpuAffinityWithinScope)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2980, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetCpuAffinityWithin, __pyx_t_3) < 0))) __PYX_ERR(0, 2980, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2983
 * 
 *     global __nvmlDeviceGetCpuAffinity
 *     data["__nvmlDeviceGetCpuAffinity"] = <intptr_t>__nvmlDeviceGetCpuAffinity             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetCpuAffinity
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCpuAffinity)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2983, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetCpuAffinity_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2983, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2986
 * 
 *     global __nvmlDeviceSetCpuAffinity
 *     data["__nvmlDeviceSetCpuAffinity"] = <intptr_t>__nvmlDeviceSetCpuAffinity             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceClearCpuAffinity
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetCpuAffinity)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2986, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetCpuAffinity_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2986, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2989
 * 
 *     global __nvmlDeviceClearCpuAffinity
 *     data["__nvmlDeviceClearCpuAffinity"] = <intptr_t>__nvmlDeviceClearCpuAffinity             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetNumaNodeId
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearCpuAffinity)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2989, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceClearCpuAffinity_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2989, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2992
 * 
 *     global __nvmlDeviceGetNumaNodeId
 *     data["__nvmlDeviceGetNumaNodeId"] = <intptr_t>__nvmlDeviceGetNumaNodeId             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetTopologyCommonAncestor
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNumaNodeId)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2992, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetNumaNodeId_2, __pyx_t_3) < 0))) __PYX_ERR(0, 2992, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2995
 * 
 *     global __nvmlDeviceGetTopologyCommonAncestor
 *     data["__nvmlDeviceGetTopologyCommonAncestor"] = <intptr_t>__nvmlDeviceGetTopologyCommonAncestor             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetTopologyNearestGpus
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTopologyCommonAncestor)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2995, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetTopologyCommonAnc, __pyx_t_3) < 0))) __PYX_ERR(0, 2995, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":2998
 * 
 *     global __nvmlDeviceGetTopologyNearestGpus
 *     data["__nvmlDeviceGetTopologyNearestGpus"] = <intptr_t>__nvmlDeviceGetTopologyNearestGpus             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetP2PStatus
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTopologyNearestGpus)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2998, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetTopologyNearestGp, __pyx_t_3) < 0))) __PYX_ERR(0, 2998, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3001
 * 
 *     global __nvmlDeviceGetP2PStatus
 *     data["__nvmlDeviceGetP2PStatus"] = <intptr_t>__nvmlDeviceGetP2PStatus             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetUUID
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetP2PStatus)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3001, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetP2PStatus_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3001, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3004
 * 
 *     global __nvmlDeviceGetUUID
 *     data["__nvmlDeviceGetUUID"] = <intptr_t>__nvmlDeviceGetUUID             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetMinorNumber
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetUUID)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3004, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetUUID_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3004, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3007
 * 
 *     global __nvmlDeviceGetMinorNumber
 *     data["__nvmlDeviceGetMinorNumber"] = <intptr_t>__nvmlDeviceGetMinorNumber             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetBoardPartNumber
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMinorNumber)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3007, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetMinorNumber_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3007, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3010
 * 
 *     global __nvmlDeviceGetBoardPartNumber
 *     data["__nvmlDeviceGetBoardPartNumber"] = <intptr_t>__nvmlDeviceGetBoardPartNumber             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetInforomVersion
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBoardPartNumber)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3010, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetBoardPartNumber_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3010, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3013
 * 
 *     global __nvmlDeviceGetInforomVersion
 *     data["__nvmlDeviceGetInforomVersion"] = <intptr_t>__nvmlDeviceGetInforomVersion             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetInforomImageVersion
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetInforomVersion)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3013, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetInforomVersion_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3013, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3016
 * 
 *     global __nvmlDeviceGetInforomImageVersion
 *     data["__nvmlDeviceGetInforomImageVersion"] = <intptr_t>__nvmlDeviceGetInforomImageVersion             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetInforomConfigurationChecksum
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetInforomImageVersion)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3016, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetInforomImageVersi, __pyx_t_3) < 0))) __PYX_ERR(0, 3016, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3019
 * 
 *     global __nvmlDeviceGetInforomConfigurationChecksum
 *     data["__nvmlDeviceGetInforomConfigurationChecksum"] = <intptr_t>__nvmlDeviceGetInforomConfigurationChecksum             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceValidateInforom
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetInforomConfigurationChecksum)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3019, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetInforomConfigurat, __pyx_t_3) < 0))) __PYX_ERR(0, 3019, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3022
 * 
 *     global __nvmlDeviceValidateInforom
 *     data["__nvmlDeviceValidateInforom"] = <intptr_t>__nvmlDeviceValidateInforom             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetLastBBXFlushTime
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceValidateInforom)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3022, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceValidateInforom_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3022, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3025
 * 
 *     global __nvmlDeviceGetLastBBXFlushTime
 *     data["__nvmlDeviceGetLastBBXFlushTime"] = <intptr_t>__nvmlDeviceGetLastBBXFlushTime             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetDisplayMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetLastBBXFlushTime)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3025, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetLastBBXFlushTime_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3025, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3028
 * 
 *     global __nvmlDeviceGetDisplayMode
 *     data["__nvmlDeviceGetDisplayMode"] = <intptr_t>__nvmlDeviceGetDisplayMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetDisplayActive
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDisplayMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3028, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetDisplayMode_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3028, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3031
 * 
 *     global __nvmlDeviceGetDisplayActive
 *     data["__nvmlDeviceGetDisplayActive"] = <intptr_t>__nvmlDeviceGetDisplayActive             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetPersistenceMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDisplayActive)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3031, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetDisplayActive_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3031, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3034
 * 
 *     global __nvmlDeviceGetPersistenceMode
 *     data["__nvmlDeviceGetPersistenceMode"] = <intptr_t>__nvmlDeviceGetPersistenceMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetPciInfoExt
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPersistenceMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3034, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetPersistenceMode_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3034, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3037
 * 
 *     global __nvmlDeviceGetPciInfoExt
 *     data["__nvmlDeviceGetPciInfoExt"] = <intptr_t>__nvmlDeviceGetPciInfoExt             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetPciInfo_v3
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPciInfoExt)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3037, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetPciInfoExt_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3037, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3040
 * 
 *     global __nvmlDeviceGetPciInfo_v3
 *     data["__nvmlDeviceGetPciInfo_v3"] = <intptr_t>__nvmlDeviceGetPciInfo_v3             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetMaxPcieLinkGeneration
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPciInfo_v3)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3040, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetPciInfo_v3_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3040, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3043
 * 
 *     global __nvmlDeviceGetMaxPcieLinkGeneration
 *     data["__nvmlDeviceGetMaxPcieLinkGeneration"] = <intptr_t>__nvmlDeviceGetMaxPcieLinkGeneration             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetGpuMaxPcieLinkGeneration
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxPcieLinkGeneration)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3043, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetMaxPcieLinkGenera, __pyx_t_3) < 0))) __PYX_ERR(0, 3043, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3046
 * 
 *     global __nvmlDeviceGetGpuMaxPcieLinkGeneration
 *     data["__nvmlDeviceGetGpuMaxPcieLinkGeneration"] = <intptr_t>__nvmlDeviceGetGpuMaxPcieLinkGeneration             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetMaxPcieLinkWidth
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuMaxPcieLinkGeneration)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3046, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetGpuMaxPcieLinkGen, __pyx_t_3) < 0))) __PYX_ERR(0, 3046, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3049
 * 
 *     global __nvmlDeviceGetMaxPcieLinkWidth
 *     data["__nvmlDeviceGetMaxPcieLinkWidth"] = <intptr_t>__nvmlDeviceGetMaxPcieLinkWidth             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetCurrPcieLinkGeneration
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxPcieLinkWidth)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3049, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetMaxPcieLinkWidth_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3049, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3052
 * 
 *     global __nvmlDeviceGetCurrPcieLinkGeneration
 *     data["__nvmlDeviceGetCurrPcieLinkGeneration"] = <intptr_t>__nvmlDeviceGetCurrPcieLinkGeneration             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetCurrPcieLinkWidth
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrPcieLinkGeneration)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3052, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetCurrPcieLinkGener, __pyx_t_3) < 0))) __PYX_ERR(0, 3052, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3055
 * 
 *     global __nvmlDeviceGetCurrPcieLinkWidth
 *     data["__nvmlDeviceGetCurrPcieLinkWidth"] = <intptr_t>__nvmlDeviceGetCurrPcieLinkWidth             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetPcieThroughput
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrPcieLinkWidth)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3055, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetCurrPcieLinkWidth_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3055, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3058
 * 
 *     global __nvmlDeviceGetPcieThroughput
 *     data["__nvmlDeviceGetPcieThroughput"] = <intptr_t>__nvmlDeviceGetPcieThroughput             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetPcieReplayCounter
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieThroughput)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3058, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetPcieThroughput_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3058, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3061
 * 
 *     global __nvmlDeviceGetPcieReplayCounter
 *     data["__nvmlDeviceGetPcieReplayCounter"] = <intptr_t>__nvmlDeviceGetPcieReplayCounter             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetClockInfo
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieReplayCounter)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3061, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetPcieReplayCounter_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3061, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3064
 * 
 *     global __nvmlDeviceGetClockInfo
 *     data["__nvmlDeviceGetClockInfo"] = <intptr_t>__nvmlDeviceGetClockInfo             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetMaxClockInfo
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClockInfo)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3064, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetClockInfo_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3064, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3067
 * 
 *     global __nvmlDeviceGetMaxClockInfo
 *     data["__nvmlDeviceGetMaxClockInfo"] = <intptr_t>__nvmlDeviceGetMaxClockInfo             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetGpcClkVfOffset
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxClockInfo)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3067, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetMaxClockInfo_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3067, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3070
 * 
 *     global __nvmlDeviceGetGpcClkVfOffset
 *     data["__nvmlDeviceGetGpcClkVfOffset"] = <intptr_t>__nvmlDeviceGetGpcClkVfOffset             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetClock
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpcClkVfOffset)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3070, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetGpcClkVfOffset_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3070, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3073
 * 
 *     global __nvmlDeviceGetClock
 *     data["__nvmlDeviceGetClock"] = <intptr_t>__nvmlDeviceGetClock             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetMaxCustomerBoostClock
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClock)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3073, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetClock_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3073, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3076
 * 
 *     global __nvmlDeviceGetMaxCustomerBoostClock
 *     data["__nvmlDeviceGetMaxCustomerBoostClock"] = <intptr_t>__nvmlDeviceGetMaxCustomerBoostClock             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetSupportedMemoryClocks
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxCustomerBoostClock)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3076, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetMaxCustomerBoostC, __pyx_t_3) < 0))) __PYX_ERR(0, 3076, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3079
 * 
 *     global __nvmlDeviceGetSupportedMemoryClocks
 *     data["__nvmlDeviceGetSupportedMemoryClocks"] = <intptr_t>__nvmlDeviceGetSupportedMemoryClocks             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetSupportedGraphicsClocks
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedMemoryClocks)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3079, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetSupportedMemoryCl, __pyx_t_3) < 0))) __PYX_ERR(0, 3079, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3082
 * 
 *     global __nvmlDeviceGetSupportedGraphicsClocks
 *     data["__nvmlDeviceGetSupportedGraphicsClocks"] = <intptr_t>__nvmlDeviceGetSupportedGraphicsClocks             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetAutoBoostedClocksEnabled
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedGraphicsClocks)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3082, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetSupportedGraphics, __pyx_t_3) < 0))) __PYX_ERR(0, 3082, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3085
 * 
 *     global __nvmlDeviceGetAutoBoostedClocksEnabled
 *     data["__nvmlDeviceGetAutoBoostedClocksEnabled"] = <intptr_t>__nvmlDeviceGetAutoBoostedClocksEnabled             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetFanSpeed
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAutoBoostedClocksEnabled)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3085, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetAutoBoostedClocks, __pyx_t_3) < 0))) __PYX_ERR(0, 3085, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3088
 * 
 *     global __nvmlDeviceGetFanSpeed
 *     data["__nvmlDeviceGetFanSpeed"] = <intptr_t>__nvmlDeviceGetFanSpeed             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetFanSpeed_v2
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanSpeed)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3088, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetFanSpeed_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3088, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3091
 * 
 *     global __nvmlDeviceGetFanSpeed_v2
 *     data["__nvmlDeviceGetFanSpeed_v2"] = <intptr_t>__nvmlDeviceGetFanSpeed_v2             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetFanSpeedRPM
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanSpeed_v2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3091, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetFanSpeed_v2_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3091, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3094
 * 
 *     global __nvmlDeviceGetFanSpeedRPM
 *     data["__nvmlDeviceGetFanSpeedRPM"] = <intptr_t>__nvmlDeviceGetFanSpeedRPM             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetTargetFanSpeed
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanSpeedRPM)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3094, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetFanSpeedRPM_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3094, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3097
 * 
 *     global __nvmlDeviceGetTargetFanSpeed
 *     data["__nvmlDeviceGetTargetFanSpeed"] = <intptr_t>__nvmlDeviceGetTargetFanSpeed             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetMinMaxFanSpeed
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTargetFanSpeed)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3097, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetTargetFanSpeed_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3097, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3100
 * 
 *     global __nvmlDeviceGetMinMaxFanSpeed
 *     data["__nvmlDeviceGetMinMaxFanSpeed"] = <intptr_t>__nvmlDeviceGetMinMaxFanSpeed             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetFanControlPolicy_v2
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMinMaxFanSpeed)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3100, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetMinMaxFanSpeed_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3100, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3103
 * 
 *     global __nvmlDeviceGetFanControlPolicy_v2
 *     data["__nvmlDeviceGetFanControlPolicy_v2"] = <intptr_t>__nvmlDeviceGetFanControlPolicy_v2             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetNumFans
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanControlPolicy_v2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3103, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetFanControlPolicy, __pyx_t_3) < 0))) __PYX_ERR(0, 3103, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3106
 * 
 *     global __nvmlDeviceGetNumFans
 *     data["__nvmlDeviceGetNumFans"] = <intptr_t>__nvmlDeviceGetNumFans             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetCoolerInfo
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNumFans)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3106, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetNumFans_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3106, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3109
 * 
 *     global __nvmlDeviceGetCoolerInfo
 *     data["__nvmlDeviceGetCoolerInfo"] = <intptr_t>__nvmlDeviceGetCoolerInfo             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetTemperatureV
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCoolerInfo)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3109, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetCoolerInfo_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3109, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3112
 * 
 *     global __nvmlDeviceGetTemperatureV
 *     data["__nvmlDeviceGetTemperatureV"] = <intptr_t>__nvmlDeviceGetTemperatureV             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetTemperatureThreshold
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTemperatureV)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3112, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetTemperatureV_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3112, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3115
 * 
 *     global __nvmlDeviceGetTemperatureThreshold
 *     data["__nvmlDeviceGetTemperatureThreshold"] = <intptr_t>__nvmlDeviceGetTemperatureThreshold             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetMarginTemperature
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTemperatureThreshold)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3115, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetTemperatureThresh, __pyx_t_3) < 0))) __PYX_ERR(0, 3115, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3118
 * 
 *     global __nvmlDeviceGetMarginTemperature
 *     data["__nvmlDeviceGetMarginTemperature"] = <intptr_t>__nvmlDeviceGetMarginTemperature             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetThermalSettings
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMarginTemperature)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3118, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetMarginTemperature_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3118, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3121
 * 
 *     global __nvmlDeviceGetThermalSettings
 *     data["__nvmlDeviceGetThermalSettings"] = <intptr_t>__nvmlDeviceGetThermalSettings             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetPerformanceState
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetThermalSettings)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3121, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetThermalSettings_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3121, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3124
 * 
 *     global __nvmlDeviceGetPerformanceState
 *     data["__nvmlDeviceGetPerformanceState"] = <intptr_t>__nvmlDeviceGetPerformanceState             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetCurrentClocksEventReasons
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPerformanceState)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3124, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetPerformanceState_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3124, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3127
 * 
 *     global __nvmlDeviceGetCurrentClocksEventReasons
 *     data["__nvmlDeviceGetCurrentClocksEventReasons"] = <intptr_t>__nvmlDeviceGetCurrentClocksEventReasons             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetSupportedClocksEventReasons
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrentClocksEventReasons)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3127, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetCurrentClocksEven, __pyx_t_3) < 0))) __PYX_ERR(0, 3127, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3130
 * 
 *     global __nvmlDeviceGetSupportedClocksEventReasons
 *     data["__nvmlDeviceGetSupportedClocksEventReasons"] = <intptr_t>__nvmlDeviceGetSupportedClocksEventReasons             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetPowerState
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedClocksEventReasons)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3130, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetSupportedClocksEv, __pyx_t_3) < 0))) __PYX_ERR(0, 3130, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3133
 * 
 *     global __nvmlDeviceGetPowerState
 *     data["__nvmlDeviceGetPowerState"] = <intptr_t>__nvmlDeviceGetPowerState             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetDynamicPstatesInfo
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerState)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3133, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetPowerState_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3133, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3136
 * 
 *     global __nvmlDeviceGetDynamicPstatesInfo
 *     data["__nvmlDeviceGetDynamicPstatesInfo"] = <intptr_t>__nvmlDeviceGetDynamicPstatesInfo             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetMemClkVfOffset
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDynamicPstatesInfo)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3136, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetDynamicPstatesInf, __pyx_t_3) < 0))) __PYX_ERR(0, 3136, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3139
 * 
 *     global __nvmlDeviceGetMemClkVfOffset
 *     data["__nvmlDeviceGetMemClkVfOffset"] = <intptr_t>__nvmlDeviceGetMemClkVfOffset             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetMinMaxClockOfPState
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemClkVfOffset)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3139, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetMemClkVfOffset_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3139, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3142
 * 
 *     global __nvmlDeviceGetMinMaxClockOfPState
 *     data["__nvmlDeviceGetMinMaxClockOfPState"] = <intptr_t>__nvmlDeviceGetMinMaxClockOfPState             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetSupportedPerformanceStates
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMinMaxClockOfPState)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3142, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetMinMaxClockOfPSta, __pyx_t_3) < 0))) __PYX_ERR(0, 3142, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3145
 * 
 *     global __nvmlDeviceGetSupportedPerformanceStates
 *     data["__nvmlDeviceGetSupportedPerformanceStates"] = <intptr_t>__nvmlDeviceGetSupportedPerformanceStates             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetGpcClkMinMaxVfOffset
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedPerformanceStates)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3145, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetSupportedPerforma, __pyx_t_3) < 0))) __PYX_ERR(0, 3145, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3148
 * 
 *     global __nvmlDeviceGetGpcClkMinMaxVfOffset
 *     data["__nvmlDeviceGetGpcClkMinMaxVfOffset"] = <intptr_t>__nvmlDeviceGetGpcClkMinMaxVfOffset             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetMemClkMinMaxVfOffset
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpcClkMinMaxVfOffset)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3148, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetGpcClkMinMaxVfOff, __pyx_t_3) < 0))) __PYX_ERR(0, 3148, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3151
 * 
 *     global __nvmlDeviceGetMemClkMinMaxVfOffset
 *     data["__nvmlDeviceGetMemClkMinMaxVfOffset"] = <intptr_t>__nvmlDeviceGetMemClkMinMaxVfOffset             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetClockOffsets
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemClkMinMaxVfOffset)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3151, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetMemClkMinMaxVfOff, __pyx_t_3) < 0))) __PYX_ERR(0, 3151, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3154
 * 
 *     global __nvmlDeviceGetClockOffsets
 *     data["__nvmlDeviceGetClockOffsets"] = <intptr_t>__nvmlDeviceGetClockOffsets             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetClockOffsets
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClockOffsets)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3154, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetClockOffsets_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3154, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3157
 * 
 *     global __nvmlDeviceSetClockOffsets
 *     data["__nvmlDeviceSetClockOffsets"] = <intptr_t>__nvmlDeviceSetClockOffsets             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetPerformanceModes
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetClockOffsets)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3157, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetClockOffsets_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3157, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3160
 * 
 *     global __nvmlDeviceGetPerformanceModes
 *     data["__nvmlDeviceGetPerformanceModes"] = <intptr_t>__nvmlDeviceGetPerformanceModes             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetCurrentClockFreqs
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPerformanceModes)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3160, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetPerformanceModes_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3160, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3163
 * 
 *     global __nvmlDeviceGetCurrentClockFreqs
 *     data["__nvmlDeviceGetCurrentClockFreqs"] = <intptr_t>__nvmlDeviceGetCurrentClockFreqs             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetPowerManagementLimit
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrentClockFreqs)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3163, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetCurrentClockFreqs_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3163, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3166
 * 
 *     global __nvmlDeviceGetPowerManagementLimit
 *     data["__nvmlDeviceGetPowerManagementLimit"] = <intptr_t>__nvmlDeviceGetPowerManagementLimit             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetPowerManagementLimitConstraints
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerManagementLimit)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3166, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetPowerManagementLi, __pyx_t_3) < 0))) __PYX_ERR(0, 3166, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3169
 * 
 *     global __nvmlDeviceGetPowerManagementLimitConstraints
 *     data["__nvmlDeviceGetPowerManagementLimitConstraints"] = <intptr_t>__nvmlDeviceGetPowerManagementLimitConstraints             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetPowerManagementDefaultLimit
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerManagementLimitConstraints)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3169, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetPowerManagementLi_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3169, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3172
 * 
 *     global __nvmlDeviceGetPowerManagementDefaultLimit
 *     data["__nvmlDeviceGetPowerManagementDefaultLimit"] = <intptr_t>__nvmlDeviceGetPowerManagementDefaultLimit             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetPowerUsage
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerManagementDefaultLimit)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3172, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetPowerManagementDe, __pyx_t_3) < 0))) __PYX_ERR(0, 3172, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3175
 * 
 *     global __nvmlDeviceGetPowerUsage
 *     data["__nvmlDeviceGetPowerUsage"] = <intptr_t>__nvmlDeviceGetPowerUsage             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetTotalEnergyConsumption
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerUsage)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3175, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetPowerUsage_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3175, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3178
 * 
 *     global __nvmlDeviceGetTotalEnergyConsumption
 *     data["__nvmlDeviceGetTotalEnergyConsumption"] = <intptr_t>__nvmlDeviceGetTotalEnergyConsumption             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetEnforcedPowerLimit
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTotalEnergyConsumption)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3178, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetTotalEnergyConsum, __pyx_t_3) < 0))) __PYX_ERR(0, 3178, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3181
 * 
 *     global __nvmlDeviceGetEnforcedPowerLimit
 *     data["__nvmlDeviceGetEnforcedPowerLimit"] = <intptr_t>__nvmlDeviceGetEnforcedPowerLimit             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetGpuOperationMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEnforcedPowerLimit)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3181, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetEnforcedPowerLimi, __pyx_t_3) < 0))) __PYX_ERR(0, 3181, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3184
 * 
 *     global __nvmlDeviceGetGpuOperationMode
 *     data["__nvmlDeviceGetGpuOperationMode"] = <intptr_t>__nvmlDeviceGetGpuOperationMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetMemoryInfo_v2
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuOperationMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3184, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetGpuOperationMode_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3184, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3187
 * 
 *     global __nvmlDeviceGetMemoryInfo_v2
 *     data["__nvmlDeviceGetMemoryInfo_v2"] = <intptr_t>__nvmlDeviceGetMemoryInfo_v2             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetComputeMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryInfo_v2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3187, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetMemoryInfo_v2_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3187, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3190
 * 
 *     global __nvmlDeviceGetComputeMode
 *     data["__nvmlDeviceGetComputeMode"] = <intptr_t>__nvmlDeviceGetComputeMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetCudaComputeCapability
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetComputeMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3190, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetComputeMode_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3190, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3193
 * 
 *     global __nvmlDeviceGetCudaComputeCapability
 *     data["__nvmlDeviceGetCudaComputeCapability"] = <intptr_t>__nvmlDeviceGetCudaComputeCapability             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetDramEncryptionMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCudaComputeCapability)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3193, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetCudaComputeCapabi, __pyx_t_3) < 0))) __PYX_ERR(0, 3193, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3196
 * 
 *     global __nvmlDeviceGetDramEncryptionMode
 *     data["__nvmlDeviceGetDramEncryptionMode"] = <intptr_t>__nvmlDeviceGetDramEncryptionMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetDramEncryptionMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDramEncryptionMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3196, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetDramEncryptionMod, __pyx_t_3) < 0))) __PYX_ERR(0, 3196, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3199
 * 
 *     global __nvmlDeviceSetDramEncryptionMode
 *     data["__nvmlDeviceSetDramEncryptionMode"] = <intptr_t>__nvmlDeviceSetDramEncryptionMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetEccMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDramEncryptionMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3199, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetDramEncryptionMod, __pyx_t_3) < 0))) __PYX_ERR(0, 3199, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3202
 * 
 *     global __nvmlDeviceGetEccMode
 *     data["__nvmlDeviceGetEccMode"] = <intptr_t>__nvmlDeviceGetEccMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetDefaultEccMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEccMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3202, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetEccMode_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3202, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3205
 * 
 *     global __nvmlDeviceGetDefaultEccMode
 *     data["__nvmlDeviceGetDefaultEccMode"] = <intptr_t>__nvmlDeviceGetDefaultEccMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetBoardId
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDefaultEccMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3205, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetDefaultEccMode_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3205, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3208
 * 
 *     global __nvmlDeviceGetBoardId
 *     data["__nvmlDeviceGetBoardId"] = <intptr_t>__nvmlDeviceGetBoardId             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetMultiGpuBoard
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBoardId)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3208, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetBoardId_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3208, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3211
 * 
 *     global __nvmlDeviceGetMultiGpuBoard
 *     data["__nvmlDeviceGetMultiGpuBoard"] = <intptr_t>__nvmlDeviceGetMultiGpuBoard             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetTotalEccErrors
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMultiGpuBoard)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3211, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetMultiGpuBoard_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3211, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3214
 * 
 *     global __nvmlDeviceGetTotalEccErrors
 *     data["__nvmlDeviceGetTotalEccErrors"] = <intptr_t>__nvmlDeviceGetTotalEccErrors             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetMemoryErrorCounter
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTotalEccErrors)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3214, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetTotalEccErrors_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3214, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3217
 * 
 *     global __nvmlDeviceGetMemoryErrorCounter
 *     data["__nvmlDeviceGetMemoryErrorCounter"] = <intptr_t>__nvmlDeviceGetMemoryErrorCounter             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetUtilizationRates
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryErrorCounter)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3217, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetMemoryErrorCounte, __pyx_t_3) < 0))) __PYX_ERR(0, 3217, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3220
 * 
 *     global __nvmlDeviceGetUtilizationRates
 *     data["__nvmlDeviceGetUtilizationRates"] = <intptr_t>__nvmlDeviceGetUtilizationRates             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetEncoderUtilization
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetUtilizationRates)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetUtilizationRates_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3220, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3223
 * 
 *     global __nvmlDeviceGetEncoderUtilization
 *     data["__nvmlDeviceGetEncoderUtilization"] = <intptr_t>__nvmlDeviceGetEncoderUtilization             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetEncoderCapacity
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderUtilization)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3223, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetEncoderUtilizatio, __pyx_t_3) < 0))) __PYX_ERR(0, 3223, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3226
 * 
 *     global __nvmlDeviceGetEncoderCapacity
 *     data["__nvmlDeviceGetEncoderCapacity"] = <intptr_t>__nvmlDeviceGetEncoderCapacity             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetEncoderStats
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderCapacity)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3226, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetEncoderCapacity_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3226, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3229
 * 
 *     global __nvmlDeviceGetEncoderStats
 *     data["__nvmlDeviceGetEncoderStats"] = <intptr_t>__nvmlDeviceGetEncoderStats             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetEncoderSessions
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderStats)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3229, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetEncoderStats_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3229, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3232
 * 
 *     global __nvmlDeviceGetEncoderSessions
 *     data["__nvmlDeviceGetEncoderSessions"] = <intptr_t>__nvmlDeviceGetEncoderSessions             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetDecoderUtilization
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderSessions)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3232, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetEncoderSessions_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3232, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3235
 * 
 *     global __nvmlDeviceGetDecoderUtilization
 *     data["__nvmlDeviceGetDecoderUtilization"] = <intptr_t>__nvmlDeviceGetDecoderUtilization             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetJpgUtilization
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDecoderUtilization)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3235, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetDecoderUtilizatio, __pyx_t_3) < 0))) __PYX_ERR(0, 3235, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3238
 * 
 *     global __nvmlDeviceGetJpgUtilization
 *     data["__nvmlDeviceGetJpgUtilization"] = <intptr_t>__nvmlDeviceGetJpgUtilization             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetOfaUtilization
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetJpgUtilization)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3238, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetJpgUtilization_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3238, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3241
 * 
 *     global __nvmlDeviceGetOfaUtilization
 *     data["__nvmlDeviceGetOfaUtilization"] = <intptr_t>__nvmlDeviceGetOfaUtilization             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetFBCStats
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetOfaUtilization)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3241, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetOfaUtilization_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3241, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3244
 * 
 *     global __nvmlDeviceGetFBCStats
 *     data["__nvmlDeviceGetFBCStats"] = <intptr_t>__nvmlDeviceGetFBCStats             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetFBCSessions
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFBCStats)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3244, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetFBCStats_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3244, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3247
 * 
 *     global __nvmlDeviceGetFBCSessions
 *     data["__nvmlDeviceGetFBCSessions"] = <intptr_t>__nvmlDeviceGetFBCSessions             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetDriverModel_v2
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFBCSessions)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3247, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetFBCSessions_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3247, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3250
 * 
 *     global __nvmlDeviceGetDriverModel_v2
 *     data["__nvmlDeviceGetDriverModel_v2"] = <intptr_t>__nvmlDeviceGetDriverModel_v2             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetVbiosVersion
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDriverModel_v2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3250, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetDriverModel_v2_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3250, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3253
 * 
 *     global __nvmlDeviceGetVbiosVersion
 *     data["__nvmlDeviceGetVbiosVersion"] = <intptr_t>__nvmlDeviceGetVbiosVersion             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetBridgeChipInfo
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVbiosVersion)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3253, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetVbiosVersion_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3253, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3256
 * 
 *     global __nvmlDeviceGetBridgeChipInfo
 *     data["__nvmlDeviceGetBridgeChipInfo"] = <intptr_t>__nvmlDeviceGetBridgeChipInfo             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetComputeRunningProcesses_v3
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBridgeChipInfo)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3256, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetBridgeChipInfo_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3256, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3259
 * 
 *     global __nvmlDeviceGetComputeRunningProcesses_v3
 *     data["__nvmlDeviceGetComputeRunningProcesses_v3"] = <intptr_t>__nvmlDeviceGetComputeRunningProcesses_v3             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetMPSComputeRunningProcesses_v3
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetComputeRunningProcesses_v3)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3259, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetComputeRunningPro, __pyx_t_3) < 0))) __PYX_ERR(0, 3259, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3262
 * 
 *     global __nvmlDeviceGetMPSComputeRunningProcesses_v3
 *     data["__nvmlDeviceGetMPSComputeRunningProcesses_v3"] = <intptr_t>__nvmlDeviceGetMPSComputeRunningProcesses_v3             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetRunningProcessDetailList
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMPSComputeRunningProcesses_v3)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3262, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetMPSComputeRunning, __pyx_t_3) < 0))) __PYX_ERR(0, 3262, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3265
 * 
 *     global __nvmlDeviceGetRunningProcessDetailList
 *     data["__nvmlDeviceGetRunningProcessDetailList"] = <intptr_t>__nvmlDeviceGetRunningProcessDetailList             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceOnSameBoard
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRunningProcessDetailList)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3265, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetRunningProcessDet, __pyx_t_3) < 0))) __PYX_ERR(0, 3265, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3268
 * 
 *     global __nvmlDeviceOnSameBoard
 *     data["__nvmlDeviceOnSameBoard"] = <intptr_t>__nvmlDeviceOnSameBoard             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetAPIRestriction
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceOnSameBoard)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3268, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceOnSameBoard_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3268, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3271
 * 
 *     global __nvmlDeviceGetAPIRestriction
 *     data["__nvmlDeviceGetAPIRestriction"] = <intptr_t>__nvmlDeviceGetAPIRestriction             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetSamples
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAPIRestriction)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3271, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetAPIRestriction_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3271, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3274
 * 
 *     global __nvmlDeviceGetSamples
 *     data["__nvmlDeviceGetSamples"] = <intptr_t>__nvmlDeviceGetSamples             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetBAR1MemoryInfo
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSamples)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3274, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetSamples_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3274, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3277
 * 
 *     global __nvmlDeviceGetBAR1MemoryInfo
 *     data["__nvmlDeviceGetBAR1MemoryInfo"] = <intptr_t>__nvmlDeviceGetBAR1MemoryInfo             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetIrqNum
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBAR1MemoryInfo)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3277, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetBAR1MemoryInfo_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3277, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3280
 * 
 *     global __nvmlDeviceGetIrqNum
 *     data["__nvmlDeviceGetIrqNum"] = <intptr_t>__nvmlDeviceGetIrqNum             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetNumGpuCores
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetIrqNum)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3280, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetIrqNum_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3280, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3283
 * 
 *     global __nvmlDeviceGetNumGpuCores
 *     data["__nvmlDeviceGetNumGpuCores"] = <intptr_t>__nvmlDeviceGetNumGpuCores             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetPowerSource
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNumGpuCores)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3283, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetNumGpuCores_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3283, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3286
 * 
 *     global __nvmlDeviceGetPowerSource
 *     data["__nvmlDeviceGetPowerSource"] = <intptr_t>__nvmlDeviceGetPowerSource             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetMemoryBusWidth
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerSource)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3286, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetPowerSource_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3286, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3289
 * 
 *     global __nvmlDeviceGetMemoryBusWidth
 *     data["__nvmlDeviceGetMemoryBusWidth"] = <intptr_t>__nvmlDeviceGetMemoryBusWidth             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetPcieLinkMaxSpeed
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryBusWidth)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3289, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetMemoryBusWidth_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3289, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3292
 * 
 *     global __nvmlDeviceGetPcieLinkMaxSpeed
 *     data["__nvmlDeviceGetPcieLinkMaxSpeed"] = <intptr_t>__nvmlDeviceGetPcieLinkMaxSpeed             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetPcieSpeed
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieLinkMaxSpeed)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3292, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetPcieLinkMaxSpeed_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3292, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3295
 * 
 *     global __nvmlDeviceGetPcieSpeed
 *     data["__nvmlDeviceGetPcieSpeed"] = <intptr_t>__nvmlDeviceGetPcieSpeed             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetAdaptiveClockInfoStatus
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieSpeed)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3295, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetPcieSpeed_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3295, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3298
 * 
 *     global __nvmlDeviceGetAdaptiveClockInfoStatus
 *     data["__nvmlDeviceGetAdaptiveClockInfoStatus"] = <intptr_t>__nvmlDeviceGetAdaptiveClockInfoStatus             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetBusType
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAdaptiveClockInfoStatus)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3298, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetAdaptiveClockInfo, __pyx_t_3) < 0))) __PYX_ERR(0, 3298, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3301
 * 
 *     global __nvmlDeviceGetBusType
 *     data["__nvmlDeviceGetBusType"] = <intptr_t>__nvmlDeviceGetBusType             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetGpuFabricInfoV
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBusType)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3301, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetBusType_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3301, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3304
 * 
 *     global __nvmlDeviceGetGpuFabricInfoV
 *     data["__nvmlDeviceGetGpuFabricInfoV"] = <intptr_t>__nvmlDeviceGetGpuFabricInfoV             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlSystemGetConfComputeCapabilities
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuFabricInfoV)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3304, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetGpuFabricInfoV_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3304, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3307
 * 
 *     global __nvmlSystemGetConfComputeCapabilities
 *     data["__nvmlSystemGetConfComputeCapabilities"] = <intptr_t>__nvmlSystemGetConfComputeCapabilities             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlSystemGetConfComputeState
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeCapabilities)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3307, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlSystemGetConfComputeCapabi, __pyx_t_3) < 0))) __PYX_ERR(0, 3307, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3310
 * 
 *     global __nvmlSystemGetConfComputeState
 *     data["__nvmlSystemGetConfComputeState"] = <intptr_t>__nvmlSystemGetConfComputeState             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetConfComputeMemSizeInfo
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeState)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3310, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlSystemGetConfComputeState_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3310, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3313
 * 
 *     global __nvmlDeviceGetConfComputeMemSizeInfo
 *     data["__nvmlDeviceGetConfComputeMemSizeInfo"] = <intptr_t>__nvmlDeviceGetConfComputeMemSizeInfo             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlSystemGetConfComputeGpusReadyState
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeMemSizeInfo)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3313, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetConfComputeMemSiz, __pyx_t_3) < 0))) __PYX_ERR(0, 3313, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3316
 * 
 *     global __nvmlSystemGetConfComputeGpusReadyState
 *     data["__nvmlSystemGetConfComputeGpusReadyState"] = <intptr_t>__nvmlSystemGetConfComputeGpusReadyState             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetConfComputeProtectedMemoryUsage
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeGpusReadyState)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3316, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlSystemGetConfComputeGpusRe, __pyx_t_3) < 0))) __PYX_ERR(0, 3316, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3319
 * 
 *     global __nvmlDeviceGetConfComputeProtectedMemoryUsage
 *     data["__nvmlDeviceGetConfComputeProtectedMemoryUsage"] = <intptr_t>__nvmlDeviceGetConfComputeProtectedMemoryUsage             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetConfComputeGpuCertificate
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeProtectedMemoryUsage)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3319, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetConfComputeProtec, __pyx_t_3) < 0))) __PYX_ERR(0, 3319, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3322
 * 
 *     global __nvmlDeviceGetConfComputeGpuCertificate
 *     data["__nvmlDeviceGetConfComputeGpuCertificate"] = <intptr_t>__nvmlDeviceGetConfComputeGpuCertificate             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetConfComputeGpuAttestationReport
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeGpuCertificate)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3322, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetConfComputeGpuCer, __pyx_t_3) < 0))) __PYX_ERR(0, 3322, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3325
 * 
 *     global __nvmlDeviceGetConfComputeGpuAttestationReport
 *     data["__nvmlDeviceGetConfComputeGpuAttestationReport"] = <intptr_t>__nvmlDeviceGetConfComputeGpuAttestationReport             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlSystemGetConfComputeKeyRotationThresholdInfo
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeGpuAttestationReport)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3325, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetConfComputeGpuAtt, __pyx_t_3) < 0))) __PYX_ERR(0, 3325, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3328
 * 
 *     global __nvmlSystemGetConfComputeKeyRotationThresholdInfo
 *     data["__nvmlSystemGetConfComputeKeyRotationThresholdInfo"] = <intptr_t>__nvmlSystemGetConfComputeKeyRotationThresholdInfo             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetConfComputeUnprotectedMemSize
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeKeyRotationThresholdInfo)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3328, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlSystemGetConfComputeKeyRot, __pyx_t_3) < 0))) __PYX_ERR(0, 3328, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3331
 * 
 *     global __nvmlDeviceSetConfComputeUnprotectedMemSize
 *     data["__nvmlDeviceSetConfComputeUnprotectedMemSize"] = <intptr_t>__nvmlDeviceSetConfComputeUnprotectedMemSize             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlSystemSetConfComputeGpusReadyState
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetConfComputeUnprotectedMemSize)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3331, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetConfComputeUnprot, __pyx_t_3) < 0))) __PYX_ERR(0, 3331, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3334
 * 
 *     global __nvmlSystemSetConfComputeGpusReadyState
 *     data["__nvmlSystemSetConfComputeGpusReadyState"] = <intptr_t>__nvmlSystemSetConfComputeGpusReadyState             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlSystemSetConfComputeKeyRotationThresholdInfo
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemSetConfComputeGpusReadyState)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3334, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlSystemSetConfComputeGpusRe, __pyx_t_3) < 0))) __PYX_ERR(0, 3334, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3337
 * 
 *     global __nvmlSystemSetConfComputeKeyRotationThresholdInfo
 *     data["__nvmlSystemSetConfComputeKeyRotationThresholdInfo"] = <intptr_t>__nvmlSystemSetConfComputeKeyRotationThresholdInfo             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlSystemGetConfComputeSettings
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemSetConfComputeKeyRotationThresholdInfo)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3337, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlSystemSetConfComputeKeyRot, __pyx_t_3) < 0))) __PYX_ERR(0, 3337, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3340
 * 
 *     global __nvmlSystemGetConfComputeSettings
 *     data["__nvmlSystemGetConfComputeSettings"] = <intptr_t>__nvmlSystemGetConfComputeSettings             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetGspFirmwareVersion
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeSettings)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3340, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlSystemGetConfComputeSettin, __pyx_t_3) < 0))) __PYX_ERR(0, 3340, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3343
 * 
 *     global __nvmlDeviceGetGspFirmwareVersion
 *     data["__nvmlDeviceGetGspFirmwareVersion"] = <intptr_t>__nvmlDeviceGetGspFirmwareVersion             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetGspFirmwareMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGspFirmwareVersion)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3343, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetGspFirmwareVersio, __pyx_t_3) < 0))) __PYX_ERR(0, 3343, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3346
 * 
 *     global __nvmlDeviceGetGspFirmwareMode
 *     data["__nvmlDeviceGetGspFirmwareMode"] = <intptr_t>__nvmlDeviceGetGspFirmwareMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetSramEccErrorStatus
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGspFirmwareMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3346, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetGspFirmwareMode_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3346, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3349
 * 
 *     global __nvmlDeviceGetSramEccErrorStatus
 *     data["__nvmlDeviceGetSramEccErrorStatus"] = <intptr_t>__nvmlDeviceGetSramEccErrorStatus             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetAccountingMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSramEccErrorStatus)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3349, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetSramEccErrorStatu, __pyx_t_3) < 0))) __PYX_ERR(0, 3349, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3352
 * 
 *     global __nvmlDeviceGetAccountingMode
 *     data["__nvmlDeviceGetAccountingMode"] = <intptr_t>__nvmlDeviceGetAccountingMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetAccountingStats
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3352, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetAccountingMode_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3352, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3355
 * 
 *     global __nvmlDeviceGetAccountingStats
 *     data["__nvmlDeviceGetAccountingStats"] = <intptr_t>__nvmlDeviceGetAccountingStats             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetAccountingPids
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingStats)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3355, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetAccountingStats_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3355, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3358
 * 
 *     global __nvmlDeviceGetAccountingPids
 *     data["__nvmlDeviceGetAccountingPids"] = <intptr_t>__nvmlDeviceGetAccountingPids             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetAccountingBufferSize
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingPids)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3358, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetAccountingPids_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3358, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3361
 * 
 *     global __nvmlDeviceGetAccountingBufferSize
 *     data["__nvmlDeviceGetAccountingBufferSize"] = <intptr_t>__nvmlDeviceGetAccountingBufferSize             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetRetiredPages
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingBufferSize)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3361, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetAccountingBufferS, __pyx_t_3) < 0))) __PYX_ERR(0, 3361, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3364
 * 
 *     global __nvmlDeviceGetRetiredPages
 *     data["__nvmlDeviceGetRetiredPages"] = <intptr_t>__nvmlDeviceGetRetiredPages             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetRetiredPages_v2
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRetiredPages)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3364, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetRetiredPages_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3364, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3367
 * 
 *     global __nvmlDeviceGetRetiredPages_v2
 *     data["__nvmlDeviceGetRetiredPages_v2"] = <intptr_t>__nvmlDeviceGetRetiredPages_v2             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetRetiredPagesPendingStatus
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRetiredPages_v2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3367, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetRetiredPages_v2_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3367, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3370
 * 
 *     global __nvmlDeviceGetRetiredPagesPendingStatus
 *     data["__nvmlDeviceGetRetiredPagesPendingStatus"] = <intptr_t>__nvmlDeviceGetRetiredPagesPendingStatus             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetRemappedRows
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRetiredPagesPendingStatus)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3370, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetRetiredPagesPendi, __pyx_t_3) < 0))) __PYX_ERR(0, 3370, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3373
 * 
 *     global __nvmlDeviceGetRemappedRows
 *     data["__nvmlDeviceGetRemappedRows"] = <intptr_t>__nvmlDeviceGetRemappedRows             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetRowRemapperHistogram
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRemappedRows)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3373, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetRemappedRows_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3373, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3376
 * 
 *     global __nvmlDeviceGetRowRemapperHistogram
 *     data["__nvmlDeviceGetRowRemapperHistogram"] = <intptr_t>__nvmlDeviceGetRowRemapperHistogram             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetArchitecture
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRowRemapperHistogram)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3376, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetRowRemapperHistog, __pyx_t_3) < 0))) __PYX_ERR(0, 3376, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3379
 * 
 *     global __nvmlDeviceGetArchitecture
 *     data["__nvmlDeviceGetArchitecture"] = <intptr_t>__nvmlDeviceGetArchitecture             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetClkMonStatus
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetArchitecture)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3379, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetArchitecture_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3379, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3382
 * 
 *     global __nvmlDeviceGetClkMonStatus
 *     data["__nvmlDeviceGetClkMonStatus"] = <intptr_t>__nvmlDeviceGetClkMonStatus             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetProcessUtilization
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClkMonStatus)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3382, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetClkMonStatus_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3382, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3385
 * 
 *     global __nvmlDeviceGetProcessUtilization
 *     data["__nvmlDeviceGetProcessUtilization"] = <intptr_t>__nvmlDeviceGetProcessUtilization             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetProcessesUtilizationInfo
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetProcessUtilization)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3385, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetProcessUtilizatio, __pyx_t_3) < 0))) __PYX_ERR(0, 3385, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3388
 * 
 *     global __nvmlDeviceGetProcessesUtilizationInfo
 *     data["__nvmlDeviceGetProcessesUtilizationInfo"] = <intptr_t>__nvmlDeviceGetProcessesUtilizationInfo             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetPlatformInfo
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetProcessesUtilizationInfo)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3388, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetProcessesUtilizat, __pyx_t_3) < 0))) __PYX_ERR(0, 3388, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3391
 * 
 *     global __nvmlDeviceGetPlatformInfo
 *     data["__nvmlDeviceGetPlatformInfo"] = <intptr_t>__nvmlDeviceGetPlatformInfo             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlUnitSetLedState
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPlatformInfo)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3391, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetPlatformInfo_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3391, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3394
 * 
 *     global __nvmlUnitSetLedState
 *     data["__nvmlUnitSetLedState"] = <intptr_t>__nvmlUnitSetLedState             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetPersistenceMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitSetLedState)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3394, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlUnitSetLedState_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3394, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3397
 * 
 *     global __nvmlDeviceSetPersistenceMode
 *     data["__nvmlDeviceSetPersistenceMode"] = <intptr_t>__nvmlDeviceSetPersistenceMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetComputeMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPersistenceMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3397, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetPersistenceMode_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3397, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3400
 * 
 *     global __nvmlDeviceSetComputeMode
 *     data["__nvmlDeviceSetComputeMode"] = <intptr_t>__nvmlDeviceSetComputeMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetEccMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetComputeMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3400, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetComputeMode_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3400, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3403
 * 
 *     global __nvmlDeviceSetEccMode
 *     data["__nvmlDeviceSetEccMode"] = <intptr_t>__nvmlDeviceSetEccMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceClearEccErrorCounts
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetEccMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3403, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetEccMode_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3403, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3406
 * 
 *     global __nvmlDeviceClearEccErrorCounts
 *     data["__nvmlDeviceClearEccErrorCounts"] = <intptr_t>__nvmlDeviceClearEccErrorCounts             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetDriverModel
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearEccErrorCounts)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3406, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceClearEccErrorCounts_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3406, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3409
 * 
 *     global __nvmlDeviceSetDriverModel
 *     data["__nvmlDeviceSetDriverModel"] = <intptr_t>__nvmlDeviceSetDriverModel             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetGpuLockedClocks
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDriverModel)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3409, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetDriverModel_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3409, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3412
 * 
 *     global __nvmlDeviceSetGpuLockedClocks
 *     data["__nvmlDeviceSetGpuLockedClocks"] = <intptr_t>__nvmlDeviceSetGpuLockedClocks             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceResetGpuLockedClocks
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetGpuLockedClocks)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3412, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetGpuLockedClocks_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3412, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3415
 * 
 *     global __nvmlDeviceResetGpuLockedClocks
 *     data["__nvmlDeviceResetGpuLockedClocks"] = <intptr_t>__nvmlDeviceResetGpuLockedClocks             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetMemoryLockedClocks
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceResetGpuLockedClocks)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3415, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceResetGpuLockedClocks_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3415, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3418
 * 
 *     global __nvmlDeviceSetMemoryLockedClocks
 *     data["__nvmlDeviceSetMemoryLockedClocks"] = <intptr_t>__nvmlDeviceSetMemoryLockedClocks             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceResetMemoryLockedClocks
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetMemoryLockedClocks)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3418, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetMemoryLockedClock, __pyx_t_3) < 0))) __PYX_ERR(0, 3418, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3421
 * 
 *     global __nvmlDeviceResetMemoryLockedClocks
 *     data["__nvmlDeviceResetMemoryLockedClocks"] = <intptr_t>__nvmlDeviceResetMemoryLockedClocks             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetAutoBoostedClocksEnabled
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceResetMemoryLockedClocks)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3421, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceResetMemoryLockedClo, __pyx_t_3) < 0))) __PYX_ERR(0, 3421, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3424
 * 
 *     global __nvmlDeviceSetAutoBoostedClocksEnabled
 *     data["__nvmlDeviceSetAutoBoostedClocksEnabled"] = <intptr_t>__nvmlDeviceSetAutoBoostedClocksEnabled             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetDefaultAutoBoostedClocksEnabled
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetAutoBoostedClocksEnabled)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3424, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetAutoBoostedClocks, __pyx_t_3) < 0))) __PYX_ERR(0, 3424, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3427
 * 
 *     global __nvmlDeviceSetDefaultAutoBoostedClocksEnabled
 *     data["__nvmlDeviceSetDefaultAutoBoostedClocksEnabled"] = <intptr_t>__nvmlDeviceSetDefaultAutoBoostedClocksEnabled             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetDefaultFanSpeed_v2
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDefaultAutoBoostedClocksEnabled)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3427, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetDefaultAutoBooste, __pyx_t_3) < 0))) __PYX_ERR(0, 3427, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3430
 * 
 *     global __nvmlDeviceSetDefaultFanSpeed_v2
 *     data["__nvmlDeviceSetDefaultFanSpeed_v2"] = <intptr_t>__nvmlDeviceSetDefaultFanSpeed_v2             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetFanControlPolicy
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDefaultFanSpeed_v2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3430, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetDefaultFanSpeed_v, __pyx_t_3) < 0))) __PYX_ERR(0, 3430, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3433
 * 
 *     global __nvmlDeviceSetFanControlPolicy
 *     data["__nvmlDeviceSetFanControlPolicy"] = <intptr_t>__nvmlDeviceSetFanControlPolicy             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetTemperatureThreshold
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetFanControlPolicy)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3433, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetFanControlPolicy_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3433, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3436
 * 
 *     global __nvmlDeviceSetTemperatureThreshold
 *     data["__nvmlDeviceSetTemperatureThreshold"] = <intptr_t>__nvmlDeviceSetTemperatureThreshold             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetPowerManagementLimit
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetTemperatureThreshold)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3436, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetTemperatureThresh, __pyx_t_3) < 0))) __PYX_ERR(0, 3436, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3439
 * 
 *     global __nvmlDeviceSetPowerManagementLimit
 *     data["__nvmlDeviceSetPowerManagementLimit"] = <intptr_t>__nvmlDeviceSetPowerManagementLimit             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetGpuOperationMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPowerManagementLimit)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3439, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetPowerManagementLi, __pyx_t_3) < 0))) __PYX_ERR(0, 3439, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3442
 * 
 *     global __nvmlDeviceSetGpuOperationMode
 *     data["__nvmlDeviceSetGpuOperationMode"] = <intptr_t>__nvmlDeviceSetGpuOperationMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetAPIRestriction
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetGpuOperationMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3442, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetGpuOperationMode_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3442, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3445
 * 
 *     global __nvmlDeviceSetAPIRestriction
 *     data["__nvmlDeviceSetAPIRestriction"] = <intptr_t>__nvmlDeviceSetAPIRestriction             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetFanSpeed_v2
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetAPIRestriction)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3445, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetAPIRestriction_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3445, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3448
 * 
 *     global __nvmlDeviceSetFanSpeed_v2
 *     data["__nvmlDeviceSetFanSpeed_v2"] = <intptr_t>__nvmlDeviceSetFanSpeed_v2             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetAccountingMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetFanSpeed_v2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3448, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetFanSpeed_v2_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3448, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3451
 * 
 *     global __nvmlDeviceSetAccountingMode
 *     data["__nvmlDeviceSetAccountingMode"] = <intptr_t>__nvmlDeviceSetAccountingMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceClearAccountingPids
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetAccountingMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3451, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetAccountingMode_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3451, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3454
 * 
 *     global __nvmlDeviceClearAccountingPids
 *     data["__nvmlDeviceClearAccountingPids"] = <intptr_t>__nvmlDeviceClearAccountingPids             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetPowerManagementLimit_v2
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearAccountingPids)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3454, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceClearAccountingPids_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3454, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3457
 * 
 *     global __nvmlDeviceSetPowerManagementLimit_v2
 *     data["__nvmlDeviceSetPowerManagementLimit_v2"] = <intptr_t>__nvmlDeviceSetPowerManagementLimit_v2             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetNvLinkState
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPowerManagementLimit_v2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3457, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetPowerManagementLi_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3457, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3460
 * 
 *     global __nvmlDeviceGetNvLinkState
 *     data["__nvmlDeviceGetNvLinkState"] = <intptr_t>__nvmlDeviceGetNvLinkState             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetNvLinkVersion
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkState)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3460, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetNvLinkState_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3460, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3463
 * 
 *     global __nvmlDeviceGetNvLinkVersion
 *     data["__nvmlDeviceGetNvLinkVersion"] = <intptr_t>__nvmlDeviceGetNvLinkVersion             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetNvLinkCapability
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkVersion)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3463, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetNvLinkVersion_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3463, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3466
 * 
 *     global __nvmlDeviceGetNvLinkCapability
 *     data["__nvmlDeviceGetNvLinkCapability"] = <intptr_t>__nvmlDeviceGetNvLinkCapability             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetNvLinkRemotePciInfo_v2
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkCapability)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3466, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetNvLinkCapability_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3466, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3469
 * 
 *     global __nvmlDeviceGetNvLinkRemotePciInfo_v2
 *     data["__nvmlDeviceGetNvLinkRemotePciInfo_v2"] = <intptr_t>__nvmlDeviceGetNvLinkRemotePciInfo_v2             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetNvLinkErrorCounter
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkRemotePciInfo_v2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3469, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetNvLinkRemotePciIn, __pyx_t_3) < 0))) __PYX_ERR(0, 3469, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3472
 * 
 *     global __nvmlDeviceGetNvLinkErrorCounter
 *     data["__nvmlDeviceGetNvLinkErrorCounter"] = <intptr_t>__nvmlDeviceGetNvLinkErrorCounter             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceResetNvLinkErrorCounters
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkErrorCounter)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3472, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetNvLinkErrorCounte, __pyx_t_3) < 0))) __PYX_ERR(0, 3472, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3475
 * 
 *     global __nvmlDeviceResetNvLinkErrorCounters
 *     data["__nvmlDeviceResetNvLinkErrorCounters"] = <intptr_t>__nvmlDeviceResetNvLinkErrorCounters             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetNvLinkRemoteDeviceType
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceResetNvLinkErrorCounters)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3475, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceResetNvLinkErrorCoun, __pyx_t_3) < 0))) __PYX_ERR(0, 3475, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3478
 * 
 *     global __nvmlDeviceGetNvLinkRemoteDeviceType
 *     data["__nvmlDeviceGetNvLinkRemoteDeviceType"] = <intptr_t>__nvmlDeviceGetNvLinkRemoteDeviceType             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetNvLinkDeviceLowPowerThreshold
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkRemoteDeviceType)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3478, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetNvLinkRemoteDevic, __pyx_t_3) < 0))) __PYX_ERR(0, 3478, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3481
 * 
 *     global __nvmlDeviceSetNvLinkDeviceLowPowerThreshold
 *     data["__nvmlDeviceSetNvLinkDeviceLowPowerThreshold"] = <intptr_t>__nvmlDeviceSetNvLinkDeviceLowPowerThreshold             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlSystemSetNvlinkBwMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetNvLinkDeviceLowPowerThreshold)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3481, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetNvLinkDeviceLowPo, __pyx_t_3) < 0))) __PYX_ERR(0, 3481, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3484
 * 
 *     global __nvmlSystemSetNvlinkBwMode
 *     data["__nvmlSystemSetNvlinkBwMode"] = <intptr_t>__nvmlSystemSetNvlinkBwMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlSystemGetNvlinkBwMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemSetNvlinkBwMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3484, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlSystemSetNvlinkBwMode_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3484, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3487
 * 
 *     global __nvmlSystemGetNvlinkBwMode
 *     data["__nvmlSystemGetNvlinkBwMode"] = <intptr_t>__nvmlSystemGetNvlinkBwMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetNvlinkSupportedBwModes
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetNvlinkBwMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3487, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlSystemGetNvlinkBwMode_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3487, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3490
 * 
 *     global __nvmlDeviceGetNvlinkSupportedBwModes
 *     data["__nvmlDeviceGetNvlinkSupportedBwModes"] = <intptr_t>__nvmlDeviceGetNvlinkSupportedBwModes             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetNvlinkBwMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvlinkSupportedBwModes)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3490, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetNvlinkSupportedBw, __pyx_t_3) < 0))) __PYX_ERR(0, 3490, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3493
 * 
 *     global __nvmlDeviceGetNvlinkBwMode
 *     data["__nvmlDeviceGetNvlinkBwMode"] = <intptr_t>__nvmlDeviceGetNvlinkBwMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetNvlinkBwMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvlinkBwMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3493, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetNvlinkBwMode_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3493, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3496
 * 
 *     global __nvmlDeviceSetNvlinkBwMode
 *     data["__nvmlDeviceSetNvlinkBwMode"] = <intptr_t>__nvmlDeviceSetNvlinkBwMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlEventSetCreate
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetNvlinkBwMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3496, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetNvlinkBwMode_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3496, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3499
 * 
 *     global __nvmlEventSetCreate
 *     data["__nvmlEventSetCreate"] = <intptr_t>__nvmlEventSetCreate             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceRegisterEvents
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlEventSetCreate)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3499, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlEventSetCreate_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3499, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3502
 * 
 *     global __nvmlDeviceRegisterEvents
 *     data["__nvmlDeviceRegisterEvents"] = <intptr_t>__nvmlDeviceRegisterEvents             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetSupportedEventTypes
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceRegisterEvents)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3502, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceRegisterEvents_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3502, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3505
 * 
 *     global __nvmlDeviceGetSupportedEventTypes
 *     data["__nvmlDeviceGetSupportedEventTypes"] = <intptr_t>__nvmlDeviceGetSupportedEventTypes             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlEventSetWait_v2
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedEventTypes)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3505, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetSupportedEventTyp, __pyx_t_3) < 0))) __PYX_ERR(0, 3505, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3508
 * 
 *     global __nvmlEventSetWait_v2
 *     data["__nvmlEventSetWait_v2"] = <intptr_t>__nvmlEventSetWait_v2             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlEventSetFree
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlEventSetWait_v2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3508, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlEventSetWait_v2_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3508, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3511
 * 
 *     global __nvmlEventSetFree
 *     data["__nvmlEventSetFree"] = <intptr_t>__nvmlEventSetFree             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlSystemEventSetCreate
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlEventSetFree)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3511, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlEventSetFree_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3511, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3514
 * 
 *     global __nvmlSystemEventSetCreate
 *     data["__nvmlSystemEventSetCreate"] = <intptr_t>__nvmlSystemEventSetCreate             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlSystemEventSetFree
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemEventSetCreate)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3514, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlSystemEventSetCreate_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3514, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3517
 * 
 *     global __nvmlSystemEventSetFree
 *     data["__nvmlSystemEventSetFree"] = <intptr_t>__nvmlSystemEventSetFree             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlSystemRegisterEvents
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemEventSetFree)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3517, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlSystemEventSetFree_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3517, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3520
 * 
 *     global __nvmlSystemRegisterEvents
 *     data["__nvmlSystemRegisterEvents"] = <intptr_t>__nvmlSystemRegisterEvents             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlSystemEventSetWait
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemRegisterEvents)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3520, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlSystemRegisterEvents_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3520, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3523
 * 
 *     global __nvmlSystemEventSetWait
 *     data["__nvmlSystemEventSetWait"] = <intptr_t>__nvmlSystemEventSetWait             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceModifyDrainState
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemEventSetWait)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3523, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlSystemEventSetWait_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3523, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3526
 * 
 *     global __nvmlDeviceModifyDrainState
 *     data["__nvmlDeviceModifyDrainState"] = <intptr_t>__nvmlDeviceModifyDrainState             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceQueryDrainState
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceModifyDrainState)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3526, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceModifyDrainState_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3526, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3529
 * 
 *     global __nvmlDeviceQueryDrainState
 *     data["__nvmlDeviceQueryDrainState"] = <intptr_t>__nvmlDeviceQueryDrainState             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceRemoveGpu_v2
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceQueryDrainState)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3529, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceQueryDrainState_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3529, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3532
 * 
 *     global __nvmlDeviceRemoveGpu_v2
 *     data["__nvmlDeviceRemoveGpu_v2"] = <intptr_t>__nvmlDeviceRemoveGpu_v2             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceDiscoverGpus
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceRemoveGpu_v2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3532, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceRemoveGpu_v2_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3532, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3535
 * 
 *     global __nvmlDeviceDiscoverGpus
 *     data["__nvmlDeviceDiscoverGpus"] = <intptr_t>__nvmlDeviceDiscoverGpus             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetFieldValues
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceDiscoverGpus)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3535, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceDiscoverGpus_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3535, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3538
 * 
 *     global __nvmlDeviceGetFieldValues
 *     data["__nvmlDeviceGetFieldValues"] = <intptr_t>__nvmlDeviceGetFieldValues             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceClearFieldValues
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFieldValues)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3538, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetFieldValues_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3538, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3541
 * 
 *     global __nvmlDeviceClearFieldValues
 *     data["__nvmlDeviceClearFieldValues"] = <intptr_t>__nvmlDeviceClearFieldValues             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetVirtualizationMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearFieldValues)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3541, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceClearFieldValues_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3541, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3544
 * 
 *     global __nvmlDeviceGetVirtualizationMode
 *     data["__nvmlDeviceGetVirtualizationMode"] = <intptr_t>__nvmlDeviceGetVirtualizationMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetHostVgpuMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVirtualizationMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3544, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetVirtualizationMod, __pyx_t_3) < 0))) __PYX_ERR(0, 3544, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3547
 * 
 *     global __nvmlDeviceGetHostVgpuMode
 *     data["__nvmlDeviceGetHostVgpuMode"] = <intptr_t>__nvmlDeviceGetHostVgpuMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetVirtualizationMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHostVgpuMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3547, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetHostVgpuMode_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3547, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3550
 * 
 *     global __nvmlDeviceSetVirtualizationMode
 *     data["__nvmlDeviceSetVirtualizationMode"] = <intptr_t>__nvmlDeviceSetVirtualizationMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetVgpuHeterogeneousMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVirtualizationMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3550, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetVirtualizationMod, __pyx_t_3) < 0))) __PYX_ERR(0, 3550, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3553
 * 
 *     global __nvmlDeviceGetVgpuHeterogeneousMode
 *     data["__nvmlDeviceGetVgpuHeterogeneousMode"] = <intptr_t>__nvmlDeviceGetVgpuHeterogeneousMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetVgpuHeterogeneousMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuHeterogeneousMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3553, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetVgpuHeterogeneous, __pyx_t_3) < 0))) __PYX_ERR(0, 3553, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3556
 * 
 *     global __nvmlDeviceSetVgpuHeterogeneousMode
 *     data["__nvmlDeviceSetVgpuHeterogeneousMode"] = <intptr_t>__nvmlDeviceSetVgpuHeterogeneousMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceGetPlacementId
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVgpuHeterogeneousMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3556, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetVgpuHeterogeneous, __pyx_t_3) < 0))) __PYX_ERR(0, 3556, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3559
 * 
 *     global __nvmlVgpuInstanceGetPlacementId
 *     data["__nvmlVgpuInstanceGetPlacementId"] = <intptr_t>__nvmlVgpuInstanceGetPlacementId             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetVgpuTypeSupportedPlacements
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetPlacementId)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3559, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceGetPlacementId_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3559, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3562
 * 
 *     global __nvmlDeviceGetVgpuTypeSupportedPlacements
 *     data["__nvmlDeviceGetVgpuTypeSupportedPlacements"] = <intptr_t>__nvmlDeviceGetVgpuTypeSupportedPlacements             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetVgpuTypeCreatablePlacements
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuTypeSupportedPlacements)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3562, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetVgpuTypeSupported, __pyx_t_3) < 0))) __PYX_ERR(0, 3562, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3565
 * 
 *     global __nvmlDeviceGetVgpuTypeCreatablePlacements
 *     data["__nvmlDeviceGetVgpuTypeCreatablePlacements"] = <intptr_t>__nvmlDeviceGetVgpuTypeCreatablePlacements             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuTypeGetGspHeapSize
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuTypeCreatablePlacements)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3565, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetVgpuTypeCreatable, __pyx_t_3) < 0))) __PYX_ERR(0, 3565, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3568
 * 
 *     global __nvmlVgpuTypeGetGspHeapSize
 *     data["__nvmlVgpuTypeGetGspHeapSize"] = <intptr_t>__nvmlVgpuTypeGetGspHeapSize             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuTypeGetFbReservation
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetGspHeapSize)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3568, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuTypeGetGspHeapSize_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3568, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3571
 * 
 *     global __nvmlVgpuTypeGetFbReservation
 *     data["__nvmlVgpuTypeGetFbReservation"] = <intptr_t>__nvmlVgpuTypeGetFbReservation             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceGetRuntimeStateSize
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetFbReservation)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3571, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuTypeGetFbReservation_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3571, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3574
 * 
 *     global __nvmlVgpuInstanceGetRuntimeStateSize
 *     data["__nvmlVgpuInstanceGetRuntimeStateSize"] = <intptr_t>__nvmlVgpuInstanceGetRuntimeStateSize             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetVgpuCapabilities
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetRuntimeStateSize)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3574, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceGetRuntimeStat, __pyx_t_3) < 0))) __PYX_ERR(0, 3574, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3577
 * 
 *     global __nvmlDeviceSetVgpuCapabilities
 *     data["__nvmlDeviceSetVgpuCapabilities"] = <intptr_t>__nvmlDeviceSetVgpuCapabilities             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetGridLicensableFeatures_v4
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVgpuCapabilities)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3577, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetVgpuCapabilities_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3577, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3580
 * 
 *     global __nvmlDeviceGetGridLicensableFeatures_v4
 *     data["__nvmlDeviceGetGridLicensableFeatures_v4"] = <intptr_t>__nvmlDeviceGetGridLicensableFeatures_v4             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGetVgpuDriverCapabilities
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGridLicensableFeatures_v4)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3580, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetGridLicensableFea, __pyx_t_3) < 0))) __PYX_ERR(0, 3580, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3583
 * 
 *     global __nvmlGetVgpuDriverCapabilities
 *     data["__nvmlGetVgpuDriverCapabilities"] = <intptr_t>__nvmlGetVgpuDriverCapabilities             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetVgpuCapabilities
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetVgpuDriverCapabilities)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3583, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGetVgpuDriverCapabilities_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3583, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3586
 * 
 *     global __nvmlDeviceGetVgpuCapabilities
 *     data["__nvmlDeviceGetVgpuCapabilities"] = <intptr_t>__nvmlDeviceGetVgpuCapabilities             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetSupportedVgpus
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuCapabilities)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3586, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetVgpuCapabilities_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3586, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3589
 * 
 *     global __nvmlDeviceGetSupportedVgpus
 *     data["__nvmlDeviceGetSupportedVgpus"] = <intptr_t>__nvmlDeviceGetSupportedVgpus             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetCreatableVgpus
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedVgpus)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3589, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetSupportedVgpus_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3589, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3592
 * 
 *     global __nvmlDeviceGetCreatableVgpus
 *     data["__nvmlDeviceGetCreatableVgpus"] = <intptr_t>__nvmlDeviceGetCreatableVgpus             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuTypeGetClass
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCreatableVgpus)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3592, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetCreatableVgpus_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3592, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3595
 * 
 *     global __nvmlVgpuTypeGetClass
 *     data["__nvmlVgpuTypeGetClass"] = <intptr_t>__nvmlVgpuTypeGetClass             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuTypeGetName
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetClass)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3595, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuTypeGetClass_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3595, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3598
 * 
 *     global __nvmlVgpuTypeGetName
 *     data["__nvmlVgpuTypeGetName"] = <intptr_t>__nvmlVgpuTypeGetName             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuTypeGetGpuInstanceProfileId
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetName)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3598, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuTypeGetName_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3598, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3601
 * 
 *     global __nvmlVgpuTypeGetGpuInstanceProfileId
 *     data["__nvmlVgpuTypeGetGpuInstanceProfileId"] = <intptr_t>__nvmlVgpuTypeGetGpuInstanceProfileId             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuTypeGetDeviceID
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetGpuInstanceProfileId)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3601, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuTypeGetGpuInstanceProf, __pyx_t_3) < 0))) __PYX_ERR(0, 3601, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3604
 * 
 *     global __nvmlVgpuTypeGetDeviceID
 *     data["__nvmlVgpuTypeGetDeviceID"] = <intptr_t>__nvmlVgpuTypeGetDeviceID             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuTypeGetFramebufferSize
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetDeviceID)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3604, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuTypeGetDeviceID_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3604, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3607
 * 
 *     global __nvmlVgpuTypeGetFramebufferSize
 *     data["__nvmlVgpuTypeGetFramebufferSize"] = <intptr_t>__nvmlVgpuTypeGetFramebufferSize             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuTypeGetNumDisplayHeads
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetFramebufferSize)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3607, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuTypeGetFramebufferSize_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3607, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3610
 * 
 *     global __nvmlVgpuTypeGetNumDisplayHeads
 *     data["__nvmlVgpuTypeGetNumDisplayHeads"] = <intptr_t>__nvmlVgpuTypeGetNumDisplayHeads             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuTypeGetResolution
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetNumDisplayHeads)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3610, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuTypeGetNumDisplayHeads_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3610, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3613
 * 
 *     global __nvmlVgpuTypeGetResolution
 *     data["__nvmlVgpuTypeGetResolution"] = <intptr_t>__nvmlVgpuTypeGetResolution             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuTypeGetLicense
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetResolution)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3613, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuTypeGetResolution_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3613, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3616
 * 
 *     global __nvmlVgpuTypeGetLicense
 *     data["__nvmlVgpuTypeGetLicense"] = <intptr_t>__nvmlVgpuTypeGetLicense             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuTypeGetFrameRateLimit
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetLicense)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3616, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuTypeGetLicense_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3616, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3619
 * 
 *     global __nvmlVgpuTypeGetFrameRateLimit
 *     data["__nvmlVgpuTypeGetFrameRateLimit"] = <intptr_t>__nvmlVgpuTypeGetFrameRateLimit             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuTypeGetMaxInstances
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetFrameRateLimit)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3619, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuTypeGetFrameRateLimit_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3619, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3622
 * 
 *     global __nvmlVgpuTypeGetMaxInstances
 *     data["__nvmlVgpuTypeGetMaxInstances"] = <intptr_t>__nvmlVgpuTypeGetMaxInstances             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuTypeGetMaxInstancesPerVm
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetMaxInstances)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3622, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuTypeGetMaxInstances_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3622, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3625
 * 
 *     global __nvmlVgpuTypeGetMaxInstancesPerVm
 *     data["__nvmlVgpuTypeGetMaxInstancesPerVm"] = <intptr_t>__nvmlVgpuTypeGetMaxInstancesPerVm             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuTypeGetBAR1Info
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetMaxInstancesPerVm)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3625, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuTypeGetMaxInstancesPer, __pyx_t_3) < 0))) __PYX_ERR(0, 3625, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3628
 * 
 *     global __nvmlVgpuTypeGetBAR1Info
 *     data["__nvmlVgpuTypeGetBAR1Info"] = <intptr_t>__nvmlVgpuTypeGetBAR1Info             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetActiveVgpus
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetBAR1Info)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3628, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuTypeGetBAR1Info_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3628, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3631
 * 
 *     global __nvmlDeviceGetActiveVgpus
 *     data["__nvmlDeviceGetActiveVgpus"] = <intptr_t>__nvmlDeviceGetActiveVgpus             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceGetVmID
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetActiveVgpus)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3631, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetActiveVgpus_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3631, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3634
 * 
 *     global __nvmlVgpuInstanceGetVmID
 *     data["__nvmlVgpuInstanceGetVmID"] = <intptr_t>__nvmlVgpuInstanceGetVmID             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceGetUUID
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetVmID)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3634, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceGetVmID_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3634, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3637
 * 
 *     global __nvmlVgpuInstanceGetUUID
 *     data["__nvmlVgpuInstanceGetUUID"] = <intptr_t>__nvmlVgpuInstanceGetUUID             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceGetVmDriverVersion
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetUUID)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3637, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceGetUUID_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3637, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3640
 * 
 *     global __nvmlVgpuInstanceGetVmDriverVersion
 *     data["__nvmlVgpuInstanceGetVmDriverVersion"] = <intptr_t>__nvmlVgpuInstanceGetVmDriverVersion             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceGetFbUsage
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetVmDriverVersion)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3640, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceGetVmDriverVer, __pyx_t_3) < 0))) __PYX_ERR(0, 3640, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3643
 * 
 *     global __nvmlVgpuInstanceGetFbUsage
 *     data["__nvmlVgpuInstanceGetFbUsage"] = <intptr_t>__nvmlVgpuInstanceGetFbUsage             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceGetLicenseStatus
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFbUsage)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3643, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceGetFbUsage_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3643, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3646
 * 
 *     global __nvmlVgpuInstanceGetLicenseStatus
 *     data["__nvmlVgpuInstanceGetLicenseStatus"] = <intptr_t>__nvmlVgpuInstanceGetLicenseStatus             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceGetType
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetLicenseStatus)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3646, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceGetLicenseStat, __pyx_t_3) < 0))) __PYX_ERR(0, 3646, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3649
 * 
 *     global __nvmlVgpuInstanceGetType
 *     data["__nvmlVgpuInstanceGetType"] = <intptr_t>__nvmlVgpuInstanceGetType             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceGetFrameRateLimit
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetType)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3649, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceGetType_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3649, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3652
 * 
 *     global __nvmlVgpuInstanceGetFrameRateLimit
 *     data["__nvmlVgpuInstanceGetFrameRateLimit"] = <intptr_t>__nvmlVgpuInstanceGetFrameRateLimit             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceGetEccMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFrameRateLimit)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3652, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceGetFrameRateLi, __pyx_t_3) < 0))) __PYX_ERR(0, 3652, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3655
 * 
 *     global __nvmlVgpuInstanceGetEccMode
 *     data["__nvmlVgpuInstanceGetEccMode"] = <intptr_t>__nvmlVgpuInstanceGetEccMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceGetEncoderCapacity
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEccMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3655, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceGetEccMode_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3655, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3658
 * 
 *     global __nvmlVgpuInstanceGetEncoderCapacity
 *     data["__nvmlVgpuInstanceGetEncoderCapacity"] = <intptr_t>__nvmlVgpuInstanceGetEncoderCapacity             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceSetEncoderCapacity
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEncoderCapacity)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3658, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceGetEncoderCapa, __pyx_t_3) < 0))) __PYX_ERR(0, 3658, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3661
 * 
 *     global __nvmlVgpuInstanceSetEncoderCapacity
 *     data["__nvmlVgpuInstanceSetEncoderCapacity"] = <intptr_t>__nvmlVgpuInstanceSetEncoderCapacity             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceGetEncoderStats
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceSetEncoderCapacity)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3661, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceSetEncoderCapa, __pyx_t_3) < 0))) __PYX_ERR(0, 3661, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3664
 * 
 *     global __nvmlVgpuInstanceGetEncoderStats
 *     data["__nvmlVgpuInstanceGetEncoderStats"] = <intptr_t>__nvmlVgpuInstanceGetEncoderStats             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceGetEncoderSessions
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEncoderStats)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3664, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceGetEncoderStat, __pyx_t_3) < 0))) __PYX_ERR(0, 3664, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3667
 * 
 *     global __nvmlVgpuInstanceGetEncoderSessions
 *     data["__nvmlVgpuInstanceGetEncoderSessions"] = <intptr_t>__nvmlVgpuInstanceGetEncoderSessions             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceGetFBCStats
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEncoderSessions)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3667, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceGetEncoderSess, __pyx_t_3) < 0))) __PYX_ERR(0, 3667, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3670
 * 
 *     global __nvmlVgpuInstanceGetFBCStats
 *     data["__nvmlVgpuInstanceGetFBCStats"] = <intptr_t>__nvmlVgpuInstanceGetFBCStats             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceGetFBCSessions
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFBCStats)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3670, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceGetFBCStats_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3670, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3673
 * 
 *     global __nvmlVgpuInstanceGetFBCSessions
 *     data["__nvmlVgpuInstanceGetFBCSessions"] = <intptr_t>__nvmlVgpuInstanceGetFBCSessions             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceGetGpuInstanceId
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFBCSessions)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3673, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceGetFBCSessions_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3673, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3676
 * 
 *     global __nvmlVgpuInstanceGetGpuInstanceId
 *     data["__nvmlVgpuInstanceGetGpuInstanceId"] = <intptr_t>__nvmlVgpuInstanceGetGpuInstanceId             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceGetGpuPciId
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetGpuInstanceId)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3676, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceGetGpuInstance, __pyx_t_3) < 0))) __PYX_ERR(0, 3676, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3679
 * 
 *     global __nvmlVgpuInstanceGetGpuPciId
 *     data["__nvmlVgpuInstanceGetGpuPciId"] = <intptr_t>__nvmlVgpuInstanceGetGpuPciId             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuTypeGetCapabilities
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetGpuPciId)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3679, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceGetGpuPciId_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3679, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3682
 * 
 *     global __nvmlVgpuTypeGetCapabilities
 *     data["__nvmlVgpuTypeGetCapabilities"] = <intptr_t>__nvmlVgpuTypeGetCapabilities             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceGetMdevUUID
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetCapabilities)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3682, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuTypeGetCapabilities_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3682, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3685
 * 
 *     global __nvmlVgpuInstanceGetMdevUUID
 *     data["__nvmlVgpuInstanceGetMdevUUID"] = <intptr_t>__nvmlVgpuInstanceGetMdevUUID             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGpuInstanceGetCreatableVgpus
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetMdevUUID)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3685, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceGetMdevUUID_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3685, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3688
 * 
 *     global __nvmlGpuInstanceGetCreatableVgpus
 *     data["__nvmlGpuInstanceGetCreatableVgpus"] = <intptr_t>__nvmlGpuInstanceGetCreatableVgpus             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuTypeGetMaxInstancesPerGpuInstance
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetCreatableVgpus)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3688, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGpuInstanceGetCreatableVgp, __pyx_t_3) < 0))) __PYX_ERR(0, 3688, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3691
 * 
 *     global __nvmlVgpuTypeGetMaxInstancesPerGpuInstance
 *     data["__nvmlVgpuTypeGetMaxInstancesPerGpuInstance"] = <intptr_t>__nvmlVgpuTypeGetMaxInstancesPerGpuInstance             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGpuInstanceGetActiveVgpus
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetMaxInstancesPerGpuInstance)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3691, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuTypeGetMaxInstancesPer_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3691, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3694
 * 
 *     global __nvmlGpuInstanceGetActiveVgpus
 *     data["__nvmlGpuInstanceGetActiveVgpus"] = <intptr_t>__nvmlGpuInstanceGetActiveVgpus             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGpuInstanceSetVgpuSchedulerState
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetActiveVgpus)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3694, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGpuInstanceGetActiveVgpus_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3694, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3697
 * 
 *     global __nvmlGpuInstanceSetVgpuSchedulerState
 *     data["__nvmlGpuInstanceSetVgpuSchedulerState"] = <intptr_t>__nvmlGpuInstanceSetVgpuSchedulerState             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGpuInstanceGetVgpuSchedulerState
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceSetVgpuSchedulerState)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3697, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGpuInstanceSetVgpuSchedule, __pyx_t_3) < 0))) __PYX_ERR(0, 3697, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3700
 * 
 *     global __nvmlGpuInstanceGetVgpuSchedulerState
 *     data["__nvmlGpuInstanceGetVgpuSchedulerState"] = <intptr_t>__nvmlGpuInstanceGetVgpuSchedulerState             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGpuInstanceGetVgpuSchedulerLog
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuSchedulerState)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3700, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGpuInstanceGetVgpuSchedule, __pyx_t_3) < 0))) __PYX_ERR(0, 3700, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3703
 * 
 *     global __nvmlGpuInstanceGetVgpuSchedulerLog
 *     data["__nvmlGpuInstanceGetVgpuSchedulerLog"] = <intptr_t>__nvmlGpuInstanceGetVgpuSchedulerLog             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGpuInstanceGetVgpuTypeCreatablePlacements
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuSchedulerLog)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3703, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGpuInstanceGetVgpuSchedule_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3703, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3706
 * 
 *     global __nvmlGpuInstanceGetVgpuTypeCreatablePlacements
 *     data["__nvmlGpuInstanceGetVgpuTypeCreatablePlacements"] = <intptr_t>__nvmlGpuInstanceGetVgpuTypeCreatablePlacements             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGpuInstanceGetVgpuHeterogeneousMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuTypeCreatablePlacements)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3706, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGpuInstanceGetVgpuTypeCrea, __pyx_t_3) < 0))) __PYX_ERR(0, 3706, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3709
 * 
 *     global __nvmlGpuInstanceGetVgpuHeterogeneousMode
 *     data["__nvmlGpuInstanceGetVgpuHeterogeneousMode"] = <intptr_t>__nvmlGpuInstanceGetVgpuHeterogeneousMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGpuInstanceSetVgpuHeterogeneousMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuHeterogeneousMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3709, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGpuInstanceGetVgpuHeteroge, __pyx_t_3) < 0))) __PYX_ERR(0, 3709, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3712
 * 
 *     global __nvmlGpuInstanceSetVgpuHeterogeneousMode
 *     data["__nvmlGpuInstanceSetVgpuHeterogeneousMode"] = <intptr_t>__nvmlGpuInstanceSetVgpuHeterogeneousMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceGetMetadata
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceSetVgpuHeterogeneousMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3712, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGpuInstanceSetVgpuHeteroge, __pyx_t_3) < 0))) __PYX_ERR(0, 3712, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3715
 * 
 *     global __nvmlVgpuInstanceGetMetadata
 *     data["__nvmlVgpuInstanceGetMetadata"] = <intptr_t>__nvmlVgpuInstanceGetMetadata             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetVgpuMetadata
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetMetadata)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3715, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceGetMetadata_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3715, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3718
 * 
 *     global __nvmlDeviceGetVgpuMetadata
 *     data["__nvmlDeviceGetVgpuMetadata"] = <intptr_t>__nvmlDeviceGetVgpuMetadata             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGetVgpuCompatibility
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuMetadata)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3718, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetVgpuMetadata_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3718, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3721
 * 
 *     global __nvmlGetVgpuCompatibility
 *     data["__nvmlGetVgpuCompatibility"] = <intptr_t>__nvmlGetVgpuCompatibility             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetPgpuMetadataString
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetVgpuCompatibility)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3721, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGetVgpuCompatibility_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3721, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3724
 * 
 *     global __nvmlDeviceGetPgpuMetadataString
 *     data["__nvmlDeviceGetPgpuMetadataString"] = <intptr_t>__nvmlDeviceGetPgpuMetadataString             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetVgpuSchedulerLog
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPgpuMetadataString)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3724, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetPgpuMetadataStrin, __pyx_t_3) < 0))) __PYX_ERR(0, 3724, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3727
 * 
 *     global __nvmlDeviceGetVgpuSchedulerLog
 *     data["__nvmlDeviceGetVgpuSchedulerLog"] = <intptr_t>__nvmlDeviceGetVgpuSchedulerLog             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetVgpuSchedulerState
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuSchedulerLog)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3727, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetVgpuSchedulerLog_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3727, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3730
 * 
 *     global __nvmlDeviceGetVgpuSchedulerState
 *     data["__nvmlDeviceGetVgpuSchedulerState"] = <intptr_t>__nvmlDeviceGetVgpuSchedulerState             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetVgpuSchedulerCapabilities
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuSchedulerState)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3730, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetVgpuSchedulerStat, __pyx_t_3) < 0))) __PYX_ERR(0, 3730, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3733
 * 
 *     global __nvmlDeviceGetVgpuSchedulerCapabilities
 *     data["__nvmlDeviceGetVgpuSchedulerCapabilities"] = <intptr_t>__nvmlDeviceGetVgpuSchedulerCapabilities             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetVgpuSchedulerState
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuSchedulerCapabilities)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3733, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetVgpuSchedulerCapa, __pyx_t_3) < 0))) __PYX_ERR(0, 3733, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3736
 * 
 *     global __nvmlDeviceSetVgpuSchedulerState
 *     data["__nvmlDeviceSetVgpuSchedulerState"] = <intptr_t>__nvmlDeviceSetVgpuSchedulerState             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGetVgpuVersion
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVgpuSchedulerState)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3736, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetVgpuSchedulerStat, __pyx_t_3) < 0))) __PYX_ERR(0, 3736, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3739
 * 
 *     global __nvmlGetVgpuVersion
 *     data["__nvmlGetVgpuVersion"] = <intptr_t>__nvmlGetVgpuVersion             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlSetVgpuVersion
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetVgpuVersion)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3739, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGetVgpuVersion_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3739, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3742
 * 
 *     global __nvmlSetVgpuVersion
 *     data["__nvmlSetVgpuVersion"] = <intptr_t>__nvmlSetVgpuVersion             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetVgpuUtilization
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSetVgpuVersion)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3742, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlSetVgpuVersion_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3742, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3745
 * 
 *     global __nvmlDeviceGetVgpuUtilization
 *     data["__nvmlDeviceGetVgpuUtilization"] = <intptr_t>__nvmlDeviceGetVgpuUtilization             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetVgpuInstancesUtilizationInfo
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuUtilization)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3745, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetVgpuUtilization_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3745, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3748
 * 
 *     global __nvmlDeviceGetVgpuInstancesUtilizationInfo
 *     data["__nvmlDeviceGetVgpuInstancesUtilizationInfo"] = <intptr_t>__nvmlDeviceGetVgpuInstancesUtilizationInfo             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetVgpuProcessUtilization
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuInstancesUtilizationInfo)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3748, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetVgpuInstancesUtil, __pyx_t_3) < 0))) __PYX_ERR(0, 3748, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3751
 * 
 *     global __nvmlDeviceGetVgpuProcessUtilization
 *     data["__nvmlDeviceGetVgpuProcessUtilization"] = <intptr_t>__nvmlDeviceGetVgpuProcessUtilization             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetVgpuProcessesUtilizationInfo
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuProcessUtilization)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3751, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetVgpuProcessUtiliz, __pyx_t_3) < 0))) __PYX_ERR(0, 3751, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3754
 * 
 *     global __nvmlDeviceGetVgpuProcessesUtilizationInfo
 *     data["__nvmlDeviceGetVgpuProcessesUtilizationInfo"] = <intptr_t>__nvmlDeviceGetVgpuProcessesUtilizationInfo             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceGetAccountingMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuProcessesUtilizationInfo)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3754, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetVgpuProcessesUtil, __pyx_t_3) < 0))) __PYX_ERR(0, 3754, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3757
 * 
 *     global __nvmlVgpuInstanceGetAccountingMode
 *     data["__nvmlVgpuInstanceGetAccountingMode"] = <intptr_t>__nvmlVgpuInstanceGetAccountingMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceGetAccountingPids
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetAccountingMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3757, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceGetAccountingM, __pyx_t_3) < 0))) __PYX_ERR(0, 3757, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3760
 * 
 *     global __nvmlVgpuInstanceGetAccountingPids
 *     data["__nvmlVgpuInstanceGetAccountingPids"] = <intptr_t>__nvmlVgpuInstanceGetAccountingPids             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceGetAccountingStats
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetAccountingPids)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3760, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceGetAccountingP, __pyx_t_3) < 0))) __PYX_ERR(0, 3760, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3763
 * 
 *     global __nvmlVgpuInstanceGetAccountingStats
 *     data["__nvmlVgpuInstanceGetAccountingStats"] = <intptr_t>__nvmlVgpuInstanceGetAccountingStats             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceClearAccountingPids
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetAccountingStats)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3763, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceGetAccountingS, __pyx_t_3) < 0))) __PYX_ERR(0, 3763, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3766
 * 
 *     global __nvmlVgpuInstanceClearAccountingPids
 *     data["__nvmlVgpuInstanceClearAccountingPids"] = <intptr_t>__nvmlVgpuInstanceClearAccountingPids             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlVgpuInstanceGetLicenseInfo_v2
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceClearAccountingPids)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3766, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceClearAccountin, __pyx_t_3) < 0))) __PYX_ERR(0, 3766, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3769
 * 
 *     global __nvmlVgpuInstanceGetLicenseInfo_v2
 *     data["__nvmlVgpuInstanceGetLicenseInfo_v2"] = <intptr_t>__nvmlVgpuInstanceGetLicenseInfo_v2             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGetExcludedDeviceCount
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetLicenseInfo_v2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3769, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlVgpuInstanceGetLicenseInfo, __pyx_t_3) < 0))) __PYX_ERR(0, 3769, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3772
 * 
 *     global __nvmlGetExcludedDeviceCount
 *     data["__nvmlGetExcludedDeviceCount"] = <intptr_t>__nvmlGetExcludedDeviceCount             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGetExcludedDeviceInfoByIndex
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetExcludedDeviceCount)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3772, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGetExcludedDeviceCount_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3772, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3775
 * 
 *     global __nvmlGetExcludedDeviceInfoByIndex
 *     data["__nvmlGetExcludedDeviceInfoByIndex"] = <intptr_t>__nvmlGetExcludedDeviceInfoByIndex             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetMigMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetExcludedDeviceInfoByIndex)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3775, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGetExcludedDeviceInfoByInd, __pyx_t_3) < 0))) __PYX_ERR(0, 3775, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3778
 * 
 *     global __nvmlDeviceSetMigMode
 *     data["__nvmlDeviceSetMigMode"] = <intptr_t>__nvmlDeviceSetMigMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetMigMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetMigMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3778, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetMigMode_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3778, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3781
 * 
 *     global __nvmlDeviceGetMigMode
 *     data["__nvmlDeviceGetMigMode"] = <intptr_t>__nvmlDeviceGetMigMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetGpuInstanceProfileInfoV
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMigMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3781, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetMigMode_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3781, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3784
 * 
 *     global __nvmlDeviceGetGpuInstanceProfileInfoV
 *     data["__nvmlDeviceGetGpuInstanceProfileInfoV"] = <intptr_t>__nvmlDeviceGetGpuInstanceProfileInfoV             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetGpuInstancePossiblePlacements_v2
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceProfileInfoV)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3784, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetGpuInstanceProfil, __pyx_t_3) < 0))) __PYX_ERR(0, 3784, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3787
 * 
 *     global __nvmlDeviceGetGpuInstancePossiblePlacements_v2
 *     data["__nvmlDeviceGetGpuInstancePossiblePlacements_v2"] = <intptr_t>__nvmlDeviceGetGpuInstancePossiblePlacements_v2             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetGpuInstanceRemainingCapacity
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstancePossiblePlacements_v2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3787, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetGpuInstancePossib, __pyx_t_3) < 0))) __PYX_ERR(0, 3787, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3790
 * 
 *     global __nvmlDeviceGetGpuInstanceRemainingCapacity
 *     data["__nvmlDeviceGetGpuInstanceRemainingCapacity"] = <intptr_t>__nvmlDeviceGetGpuInstanceRemainingCapacity             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceCreateGpuInstance
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceRemainingCapacity)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3790, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetGpuInstanceRemain, __pyx_t_3) < 0))) __PYX_ERR(0, 3790, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3793
 * 
 *     global __nvmlDeviceCreateGpuInstance
 *     data["__nvmlDeviceCreateGpuInstance"] = <intptr_t>__nvmlDeviceCreateGpuInstance             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceCreateGpuInstanceWithPlacement
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceCreateGpuInstance)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3793, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceCreateGpuInstance_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3793, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3796
 * 
 *     global __nvmlDeviceCreateGpuInstanceWithPlacement
 *     data["__nvmlDeviceCreateGpuInstanceWithPlacement"] = <intptr_t>__nvmlDeviceCreateGpuInstanceWithPlacement             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGpuInstanceDestroy
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceCreateGpuInstanceWithPlacement)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3796, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceCreateGpuInstanceWit, __pyx_t_3) < 0))) __PYX_ERR(0, 3796, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3799
 * 
 *     global __nvmlGpuInstanceDestroy
 *     data["__nvmlGpuInstanceDestroy"] = <intptr_t>__nvmlGpuInstanceDestroy             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetGpuInstances
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceDestroy)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3799, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGpuInstanceDestroy_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3799, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3802
 * 
 *     global __nvmlDeviceGetGpuInstances
 *     data["__nvmlDeviceGetGpuInstances"] = <intptr_t>__nvmlDeviceGetGpuInstances             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetGpuInstanceById
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstances)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3802, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetGpuInstances_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3802, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3805
 * 
 *     global __nvmlDeviceGetGpuInstanceById
 *     data["__nvmlDeviceGetGpuInstanceById"] = <intptr_t>__nvmlDeviceGetGpuInstanceById             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGpuInstanceGetInfo
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceById)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3805, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetGpuInstanceById_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3805, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3808
 * 
 *     global __nvmlGpuInstanceGetInfo
 *     data["__nvmlGpuInstanceGetInfo"] = <intptr_t>__nvmlGpuInstanceGetInfo             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGpuInstanceGetComputeInstanceProfileInfoV
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetInfo)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3808, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGpuInstanceGetInfo_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3808, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3811
 * 
 *     global __nvmlGpuInstanceGetComputeInstanceProfileInfoV
 *     data["__nvmlGpuInstanceGetComputeInstanceProfileInfoV"] = <intptr_t>__nvmlGpuInstanceGetComputeInstanceProfileInfoV             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGpuInstanceGetComputeInstanceRemainingCapacity
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstanceProfileInfoV)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3811, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGpuInstanceGetComputeInsta, __pyx_t_3) < 0))) __PYX_ERR(0, 3811, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3814
 * 
 *     global __nvmlGpuInstanceGetComputeInstanceRemainingCapacity
 *     data["__nvmlGpuInstanceGetComputeInstanceRemainingCapacity"] = <intptr_t>__nvmlGpuInstanceGetComputeInstanceRemainingCapacity             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGpuInstanceGetComputeInstancePossiblePlacements
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstanceRemainingCapacity)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3814, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGpuInstanceGetComputeInsta_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3814, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3817
 * 
 *     global __nvmlGpuInstanceGetComputeInstancePossiblePlacements
 *     data["__nvmlGpuInstanceGetComputeInstancePossiblePlacements"] = <intptr_t>__nvmlGpuInstanceGetComputeInstancePossiblePlacements             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGpuInstanceCreateComputeInstance
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstancePossiblePlacements)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3817, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGpuInstanceGetComputeInsta_3, __pyx_t_3) < 0))) __PYX_ERR(0, 3817, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3820
 * 
 *     global __nvmlGpuInstanceCreateComputeInstance
 *     data["__nvmlGpuInstanceCreateComputeInstance"] = <intptr_t>__nvmlGpuInstanceCreateComputeInstance             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGpuInstanceCreateComputeInstanceWithPlacement
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceCreateComputeInstance)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3820, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGpuInstanceCreateComputeIn, __pyx_t_3) < 0))) __PYX_ERR(0, 3820, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3823
 * 
 *     global __nvmlGpuInstanceCreateComputeInstanceWithPlacement
 *     data["__nvmlGpuInstanceCreateComputeInstanceWithPlacement"] = <intptr_t>__nvmlGpuInstanceCreateComputeInstanceWithPlacement             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlComputeInstanceDestroy
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceCreateComputeInstanceWithPlacement)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3823, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGpuInstanceCreateComputeIn_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3823, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3826
 * 
 *     global __nvmlComputeInstanceDestroy
 *     data["__nvmlComputeInstanceDestroy"] = <intptr_t>__nvmlComputeInstanceDestroy             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGpuInstanceGetComputeInstances
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlComputeInstanceDestroy)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3826, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlComputeInstanceDestroy_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3826, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3829
 * 
 *     global __nvmlGpuInstanceGetComputeInstances
 *     data["__nvmlGpuInstanceGetComputeInstances"] = <intptr_t>__nvmlGpuInstanceGetComputeInstances             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGpuInstanceGetComputeInstanceById
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstances)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3829, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGpuInstanceGetComputeInsta_4, __pyx_t_3) < 0))) __PYX_ERR(0, 3829, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3832
 * 
 *     global __nvmlGpuInstanceGetComputeInstanceById
 *     data["__nvmlGpuInstanceGetComputeInstanceById"] = <intptr_t>__nvmlGpuInstanceGetComputeInstanceById             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlComputeInstanceGetInfo_v2
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstanceById)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3832, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGpuInstanceGetComputeInsta_5, __pyx_t_3) < 0))) __PYX_ERR(0, 3832, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3835
 * 
 *     global __nvmlComputeInstanceGetInfo_v2
 *     data["__nvmlComputeInstanceGetInfo_v2"] = <intptr_t>__nvmlComputeInstanceGetInfo_v2             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceIsMigDeviceHandle
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlComputeInstanceGetInfo_v2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3835, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlComputeInstanceGetInfo_v2_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3835, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3838
 * 
 *     global __nvmlDeviceIsMigDeviceHandle
 *     data["__nvmlDeviceIsMigDeviceHandle"] = <intptr_t>__nvmlDeviceIsMigDeviceHandle             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetGpuInstanceId
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceIsMigDeviceHandle)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3838, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceIsMigDeviceHandle_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3838, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3841
 * 
 *     global __nvmlDeviceGetGpuInstanceId
 *     data["__nvmlDeviceGetGpuInstanceId"] = <intptr_t>__nvmlDeviceGetGpuInstanceId             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetComputeInstanceId
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceId)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3841, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetGpuInstanceId_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3841, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3844
 * 
 *     global __nvmlDeviceGetComputeInstanceId
 *     data["__nvmlDeviceGetComputeInstanceId"] = <intptr_t>__nvmlDeviceGetComputeInstanceId             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetMaxMigDeviceCount
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetComputeInstanceId)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3844, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetComputeInstanceId_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3844, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3847
 * 
 *     global __nvmlDeviceGetMaxMigDeviceCount
 *     data["__nvmlDeviceGetMaxMigDeviceCount"] = <intptr_t>__nvmlDeviceGetMaxMigDeviceCount             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetMigDeviceHandleByIndex
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxMigDeviceCount)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3847, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetMaxMigDeviceCount_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3847, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3850
 * 
 *     global __nvmlDeviceGetMigDeviceHandleByIndex
 *     data["__nvmlDeviceGetMigDeviceHandleByIndex"] = <intptr_t>__nvmlDeviceGetMigDeviceHandleByIndex             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetDeviceHandleFromMigDeviceHandle
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMigDeviceHandleByIndex)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3850, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetMigDeviceHandleBy, __pyx_t_3) < 0))) __PYX_ERR(0, 3850, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3853
 * 
 *     global __nvmlDeviceGetDeviceHandleFromMigDeviceHandle
 *     data["__nvmlDeviceGetDeviceHandleFromMigDeviceHandle"] = <intptr_t>__nvmlDeviceGetDeviceHandleFromMigDeviceHandle             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGpmSampleGet
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDeviceHandleFromMigDeviceHandle)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3853, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetDeviceHandleFromM, __pyx_t_3) < 0))) __PYX_ERR(0, 3853, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3856
 * 
 *     global __nvmlGpmSampleGet
 *     data["__nvmlGpmSampleGet"] = <intptr_t>__nvmlGpmSampleGet             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGpmMigSampleGet
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmSampleGet)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3856, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGpmSampleGet_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3856, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3859
 * 
 *     global __nvmlGpmMigSampleGet
 *     data["__nvmlGpmMigSampleGet"] = <intptr_t>__nvmlGpmMigSampleGet             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGpmQueryDeviceSupport
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmMigSampleGet)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3859, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGpmMigSampleGet_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3859, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3862
 * 
 *     global __nvmlGpmQueryDeviceSupport
 *     data["__nvmlGpmQueryDeviceSupport"] = <intptr_t>__nvmlGpmQueryDeviceSupport             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGpmQueryIfStreamingEnabled
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmQueryDeviceSupport)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3862, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGpmQueryDeviceSupport_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3862, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3865
 * 
 *     global __nvmlGpmQueryIfStreamingEnabled
 *     data["__nvmlGpmQueryIfStreamingEnabled"] = <intptr_t>__nvmlGpmQueryIfStreamingEnabled             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlGpmSetStreamingEnabled
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmQueryIfStreamingEnabled)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3865, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGpmQueryIfStreamingEnabled_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3865, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3868
 * 
 *     global __nvmlGpmSetStreamingEnabled
 *     data["__nvmlGpmSetStreamingEnabled"] = <intptr_t>__nvmlGpmSetStreamingEnabled             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetCapabilities
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmSetStreamingEnabled)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3868, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlGpmSetStreamingEnabled_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3868, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3871
 * 
 *     global __nvmlDeviceGetCapabilities
 *     data["__nvmlDeviceGetCapabilities"] = <intptr_t>__nvmlDeviceGetCapabilities             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCapabilities)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetCapabilities_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3871, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3874
 * 
 *     global __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles
 *     data["__nvmlDeviceWorkloadPowerProfileClearRequestedProfiles"] = <intptr_t>__nvmlDeviceWorkloadPowerProfileClearRequestedProfiles             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDevicePowerSmoothingActivatePresetProfile
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceWorkloadPowerProfileClearRequestedProfiles)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3874, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceWorkloadPowerProfile, __pyx_t_3) < 0))) __PYX_ERR(0, 3874, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3877
 * 
 *     global __nvmlDevicePowerSmoothingActivatePresetProfile
 *     data["__nvmlDevicePowerSmoothingActivatePresetProfile"] = <intptr_t>__nvmlDevicePowerSmoothingActivatePresetProfile             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDevicePowerSmoothingUpdatePresetProfileParam
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDevicePowerSmoothingActivatePresetProfile)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3877, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDevicePowerSmoothingActiva, __pyx_t_3) < 0))) __PYX_ERR(0, 3877, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3880
 * 
 *     global __nvmlDevicePowerSmoothingUpdatePresetProfileParam
 *     data["__nvmlDevicePowerSmoothingUpdatePresetProfileParam"] = <intptr_t>__nvmlDevicePowerSmoothingUpdatePresetProfileParam             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDevicePowerSmoothingSetState
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDevicePowerSmoothingUpdatePresetProfileParam)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3880, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDevicePowerSmoothingUpdate, __pyx_t_3) < 0))) __PYX_ERR(0, 3880, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3883
 * 
 *     global __nvmlDevicePowerSmoothingSetState
 *     data["__nvmlDevicePowerSmoothingSetState"] = <intptr_t>__nvmlDevicePowerSmoothingSetState             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetAddressingMode
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDevicePowerSmoothingSetState)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3883, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDevicePowerSmoothingSetSta, __pyx_t_3) < 0))) __PYX_ERR(0, 3883, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3886
 * 
 *     global __nvmlDeviceGetAddressingMode
 *     data["__nvmlDeviceGetAddressingMode"] = <intptr_t>__nvmlDeviceGetAddressingMode             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetRepairStatus
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAddressingMode)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3886, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetAddressingMode_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3886, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3889
 * 
 *     global __nvmlDeviceGetRepairStatus
 *     data["__nvmlDeviceGetRepairStatus"] = <intptr_t>__nvmlDeviceGetRepairStatus             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetPowerMizerMode_v1
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRepairStatus)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3889, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetRepairStatus_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3889, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3892
 * 
 *     global __nvmlDeviceGetPowerMizerMode_v1
 *     data["__nvmlDeviceGetPowerMizerMode_v1"] = <intptr_t>__nvmlDeviceGetPowerMizerMode_v1             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetPowerMizerMode_v1
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerMizerMode_v1)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3892, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetPowerMizerMode_v1_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3892, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3895
 * 
 *     global __nvmlDeviceSetPowerMizerMode_v1
 *     data["__nvmlDeviceSetPowerMizerMode_v1"] = <intptr_t>__nvmlDeviceSetPowerMizerMode_v1             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetPdi
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPowerMizerMode_v1)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3895, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetPowerMizerMode_v1_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3895, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3898
 * 
 *     global __nvmlDeviceGetPdi
 *     data["__nvmlDeviceGetPdi"] = <intptr_t>__nvmlDeviceGetPdi             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceSetHostname_v1
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPdi)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3898, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetPdi_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3898, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3901
 * 
 *     global __nvmlDeviceSetHostname_v1
 *     data["__nvmlDeviceSetHostname_v1"] = <intptr_t>__nvmlDeviceSetHostname_v1             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetHostname_v1
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetHostname_v1)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3901, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceSetHostname_v1_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3901, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3904
 * 
 *     global __nvmlDeviceGetHostname_v1
 *     data["__nvmlDeviceGetHostname_v1"] = <intptr_t>__nvmlDeviceGetHostname_v1             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetNvLinkInfo
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHostname_v1)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3904, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetHostname_v1_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3904, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3907
 * 
 *     global __nvmlDeviceGetNvLinkInfo
 *     data["__nvmlDeviceGetNvLinkInfo"] = <intptr_t>__nvmlDeviceGetNvLinkInfo             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceReadWritePRM_v1
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkInfo)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3907, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetNvLinkInfo_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3907, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3910
 * 
 *     global __nvmlDeviceReadWritePRM_v1
 *     data["__nvmlDeviceReadWritePRM_v1"] = <intptr_t>__nvmlDeviceReadWritePRM_v1             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetGpuInstanceProfileInfoByIdV
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceReadWritePRM_v1)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3910, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceReadWritePRM_v1_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3910, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3913
 * 
 *     global __nvmlDeviceGetGpuInstanceProfileInfoByIdV
 *     data["__nvmlDeviceGetGpuInstanceProfileInfoByIdV"] = <intptr_t>__nvmlDeviceGetGpuInstanceProfileInfoByIdV             # <<<<<<<<<<<<<<
 * 
 *     global __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceProfileInfoByIdV)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3913, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetGpuInstanceProfil_2, __pyx_t_3) < 0))) __PYX_ERR(0, 3913, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3916
 * 
 *     global __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts
 *     data["__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts"] = <intptr_t>__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts             # <<<<<<<<<<<<<<
 * 
 *     func_ptrs = data
*/
  __pyx_t_3 = PyLong_FromSsize_t(((intptr_t)__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3916, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (unlikely((PyDict_SetItem(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_nvmlDeviceGetSramUniqueUncorre, __pyx_t_3) < 0))) __PYX_ERR(0, 3916, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3918
 *     data["__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts"] = <intptr_t>__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts
 * 
 *     func_ptrs = data             # <<<<<<<<<<<<<<
 *     return data
 * 
*/
  __Pyx_INCREF(__pyx_v_data);
  __Pyx_XGOTREF(__pyx_v_4cuda_8bindings_9_internal_5_nvml_func_ptrs);
  __Pyx_DECREF_SET(__pyx_v_4cuda_8bindings_9_internal_5_nvml_func_ptrs, __pyx_v_data);
  __Pyx_GIVEREF(__pyx_v_data);

  /* "cuda/bindings/_internal/_nvml.pyx":3919
 * 
 *     func_ptrs = data
 *     return data             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_data);
  __pyx_r = __pyx_v_data;
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":2869
 * 
 * 
 * cpdef dict _inspect_function_pointers():             # <<<<<<<<<<<<<<
 *     global func_ptrs
 *     if func_ptrs is not None:
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._inspect_function_pointers", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_data);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_4cuda_8bindings_9_internal_5_nvml_1_inspect_function_pointers(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
PyDoc_STRVAR(__pyx_doc_4cuda_8bindings_9_internal_5_nvml__inspect_function_pointers, "_inspect_function_pointers() -> dict");
static PyMethodDef __pyx_mdef_4cuda_8bindings_9_internal_5_nvml_1_inspect_function_pointers = {"_inspect_function_pointers", (PyCFunction)__pyx_pw_4cuda_8bindings_9_internal_5_nvml_1_inspect_function_pointers, METH_NOARGS, __pyx_doc_4cuda_8bindings_9_internal_5_nvml__inspect_function_pointers};
static PyObject *__pyx_pw_4cuda_8bindings_9_internal_5_nvml_1_inspect_function_pointers(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_inspect_function_pointers (wrapper)", 0);
  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
  __pyx_r = __pyx_pf_4cuda_8bindings_9_internal_5_nvml__inspect_function_pointers(__pyx_self);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_4cuda_8bindings_9_internal_5_nvml__inspect_function_pointers(CYTHON_UNUSED PyObject *__pyx_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("_inspect_function_pointers", 0);
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__inspect_function_pointers(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2869, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._inspect_function_pointers", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":3922
 * 
 * 
 * cpdef _inspect_function_pointer(str name):             # <<<<<<<<<<<<<<
 *     global func_ptrs
 *     if func_ptrs is None:
*/

static PyObject *__pyx_pw_4cuda_8bindings_9_internal_5_nvml_3_inspect_function_pointer(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyObject *__pyx_f_4cuda_8bindings_9_internal_5_nvml__inspect_function_pointer(PyObject *__pyx_v_name, CYTHON_UNUSED int __pyx_skip_dispatch) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("_inspect_function_pointer", 0);

  /* "cuda/bindings/_internal/_nvml.pyx":3924
 * cpdef _inspect_function_pointer(str name):
 *     global func_ptrs
 *     if func_ptrs is None:             # <<<<<<<<<<<<<<
 *         func_ptrs = _inspect_function_pointers()
 *     return func_ptrs[name]
*/
  __pyx_t_1 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml_func_ptrs == ((PyObject*)Py_None));
  if (__pyx_t_1) {

    /* "cuda/bindings/_internal/_nvml.pyx":3925
 *     global func_ptrs
 *     if func_ptrs is None:
 *         func_ptrs = _inspect_function_pointers()             # <<<<<<<<<<<<<<
 *     return func_ptrs[name]
 * 
*/
    __pyx_t_2 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__inspect_function_pointers(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3925, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XGOTREF(__pyx_v_4cuda_8bindings_9_internal_5_nvml_func_ptrs);
    __Pyx_DECREF_SET(__pyx_v_4cuda_8bindings_9_internal_5_nvml_func_ptrs, ((PyObject*)__pyx_t_2));
    __Pyx_GIVEREF(__pyx_t_2);
    __pyx_t_2 = 0;

    /* "cuda/bindings/_internal/_nvml.pyx":3924
 * cpdef _inspect_function_pointer(str name):
 *     global func_ptrs
 *     if func_ptrs is None:             # <<<<<<<<<<<<<<
 *         func_ptrs = _inspect_function_pointers()
 *     return func_ptrs[name]
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":3926
 *     if func_ptrs is None:
 *         func_ptrs = _inspect_function_pointers()
 *     return func_ptrs[name]             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __Pyx_XDECREF(__pyx_r);
  if (unlikely(__pyx_v_4cuda_8bindings_9_internal_5_nvml_func_ptrs == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
    __PYX_ERR(0, 3926, __pyx_L1_error)
  }
  __pyx_t_2 = __Pyx_PyDict_GetItem(__pyx_v_4cuda_8bindings_9_internal_5_nvml_func_ptrs, __pyx_v_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3926, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":3922
 * 
 * 
 * cpdef _inspect_function_pointer(str name):             # <<<<<<<<<<<<<<
 *     global func_ptrs
 *     if func_ptrs is None:
*/

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._inspect_function_pointer", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_4cuda_8bindings_9_internal_5_nvml_3_inspect_function_pointer(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_4cuda_8bindings_9_internal_5_nvml_2_inspect_function_pointer, "_inspect_function_pointer(str name)");
static PyMethodDef __pyx_mdef_4cuda_8bindings_9_internal_5_nvml_3_inspect_function_pointer = {"_inspect_function_pointer", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cuda_8bindings_9_internal_5_nvml_3_inspect_function_pointer, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cuda_8bindings_9_internal_5_nvml_2_inspect_function_pointer};
static PyObject *__pyx_pw_4cuda_8bindings_9_internal_5_nvml_3_inspect_function_pointer(PyObject *__pyx_self, 
#if CYTHON_METH_FASTCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_name = 0;
  #if !CYTHON_METH_FASTCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject* values[1] = {0};
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_inspect_function_pointer (wrapper)", 0);
  #if !CYTHON_METH_FASTCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_name,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3922, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3922, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_inspect_function_pointer", 0) < (0)) __PYX_ERR(0, 3922, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_inspect_function_pointer", 1, 1, 1, i); __PYX_ERR(0, 3922, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3922, __pyx_L3_error)
    }
    __pyx_v_name = ((PyObject*)values[0]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("_inspect_function_pointer", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3922, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._inspect_function_pointer", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_name), (&PyUnicode_Type), 1, "name", 1))) __PYX_ERR(0, 3922, __pyx_L1_error)
  __pyx_r = __pyx_pf_4cuda_8bindings_9_internal_5_nvml_2_inspect_function_pointer(__pyx_self, __pyx_v_name);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_4cuda_8bindings_9_internal_5_nvml_2_inspect_function_pointer(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_name) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("_inspect_function_pointer", 0);
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__inspect_function_pointer(__pyx_v_name, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3922, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._inspect_function_pointer", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":3933
 * ###############################################################################
 * 
 * cdef nvmlReturn_t _nvmlInit_v2() except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlInit_v2
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlInit_v2(void) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlInit_v2", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":3935
 * cdef nvmlReturn_t _nvmlInit_v2() except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlInit_v2
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlInit_v2 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 3935, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":3936
 *     global __nvmlInit_v2
 *     _check_or_init_nvml()
 *     if __nvmlInit_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlInit_v2 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlInit_v2 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":3937
 *     _check_or_init_nvml()
 *     if __nvmlInit_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlInit_v2 is not found")
 *     return (<nvmlReturn_t (*)() noexcept nogil>__nvmlInit_v2)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":3938
 *     if __nvmlInit_v2 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlInit_v2 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)() noexcept nogil>__nvmlInit_v2)(
 *         )
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3938, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlInit_v2_is_not_foun};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3938, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 3938, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":3937
 *     _check_or_init_nvml()
 *     if __nvmlInit_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlInit_v2 is not found")
 *     return (<nvmlReturn_t (*)() noexcept nogil>__nvmlInit_v2)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":3936
 *     global __nvmlInit_v2
 *     _check_or_init_nvml()
 *     if __nvmlInit_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlInit_v2 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":3939
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlInit_v2 is not found")
 *     return (<nvmlReturn_t (*)() noexcept nogil>__nvmlInit_v2)(             # <<<<<<<<<<<<<<
 *         )
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(void))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlInit_v2)();
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":3933
 * ###############################################################################
 * 
 * cdef nvmlReturn_t _nvmlInit_v2() except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlInit_v2
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlInit_v2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":3943
 * 
 * 
 * cdef nvmlReturn_t _nvmlInitWithFlags(unsigned int flags) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlInitWithFlags
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlInitWithFlags(unsigned int __pyx_v_flags) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlInitWithFlags", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":3945
 * cdef nvmlReturn_t _nvmlInitWithFlags(unsigned int flags) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlInitWithFlags
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlInitWithFlags == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 3945, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":3946
 *     global __nvmlInitWithFlags
 *     _check_or_init_nvml()
 *     if __nvmlInitWithFlags == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlInitWithFlags is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlInitWithFlags == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":3947
 *     _check_or_init_nvml()
 *     if __nvmlInitWithFlags == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlInitWithFlags is not found")
 *     return (<nvmlReturn_t (*)(unsigned int) noexcept nogil>__nvmlInitWithFlags)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":3948
 *     if __nvmlInitWithFlags == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlInitWithFlags is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(unsigned int) noexcept nogil>__nvmlInitWithFlags)(
 *         flags)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3948, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlInitWithFlags_is_no};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3948, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 3948, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":3947
 *     _check_or_init_nvml()
 *     if __nvmlInitWithFlags == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlInitWithFlags is not found")
 *     return (<nvmlReturn_t (*)(unsigned int) noexcept nogil>__nvmlInitWithFlags)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":3946
 *     global __nvmlInitWithFlags
 *     _check_or_init_nvml()
 *     if __nvmlInitWithFlags == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlInitWithFlags is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":3949
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlInitWithFlags is not found")
 *     return (<nvmlReturn_t (*)(unsigned int) noexcept nogil>__nvmlInitWithFlags)(             # <<<<<<<<<<<<<<
 *         flags)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlInitWithFlags)(__pyx_v_flags);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":3943
 * 
 * 
 * cdef nvmlReturn_t _nvmlInitWithFlags(unsigned int flags) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlInitWithFlags
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlInitWithFlags", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":3953
 * 
 * 
 * cdef nvmlReturn_t _nvmlShutdown() except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlShutdown
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlShutdown(void) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlShutdown", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":3955
 * cdef nvmlReturn_t _nvmlShutdown() except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlShutdown
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlShutdown == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 3955, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":3956
 *     global __nvmlShutdown
 *     _check_or_init_nvml()
 *     if __nvmlShutdown == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlShutdown is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlShutdown == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":3957
 *     _check_or_init_nvml()
 *     if __nvmlShutdown == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlShutdown is not found")
 *     return (<nvmlReturn_t (*)() noexcept nogil>__nvmlShutdown)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":3958
 *     if __nvmlShutdown == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlShutdown is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)() noexcept nogil>__nvmlShutdown)(
 *         )
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3958, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlShutdown_is_not_fou};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3958, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 3958, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":3957
 *     _check_or_init_nvml()
 *     if __nvmlShutdown == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlShutdown is not found")
 *     return (<nvmlReturn_t (*)() noexcept nogil>__nvmlShutdown)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":3956
 *     global __nvmlShutdown
 *     _check_or_init_nvml()
 *     if __nvmlShutdown == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlShutdown is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":3959
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlShutdown is not found")
 *     return (<nvmlReturn_t (*)() noexcept nogil>__nvmlShutdown)(             # <<<<<<<<<<<<<<
 *         )
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(void))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlShutdown)();
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":3953
 * 
 * 
 * cdef nvmlReturn_t _nvmlShutdown() except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlShutdown
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlShutdown", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":3963
 * 
 * 
 * cdef const char* _nvmlErrorString(nvmlReturn_t result) except?NULL nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlErrorString
 *     _check_or_init_nvml()
*/

static char const *__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlErrorString(nvmlReturn_t __pyx_v_result) {
  char const *__pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlErrorString", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":3965
 * cdef const char* _nvmlErrorString(nvmlReturn_t result) except?NULL nogil:
 *     global __nvmlErrorString
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlErrorString == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 3965, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":3966
 *     global __nvmlErrorString
 *     _check_or_init_nvml()
 *     if __nvmlErrorString == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlErrorString is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlErrorString == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":3967
 *     _check_or_init_nvml()
 *     if __nvmlErrorString == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlErrorString is not found")
 *     return (<const char* (*)(nvmlReturn_t) noexcept nogil>__nvmlErrorString)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":3968
 *     if __nvmlErrorString == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlErrorString is not found")             # <<<<<<<<<<<<<<
 *     return (<const char* (*)(nvmlReturn_t) noexcept nogil>__nvmlErrorString)(
 *         result)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3968, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlErrorString_is_not};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3968, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 3968, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":3967
 *     _check_or_init_nvml()
 *     if __nvmlErrorString == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlErrorString is not found")
 *     return (<const char* (*)(nvmlReturn_t) noexcept nogil>__nvmlErrorString)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":3966
 *     global __nvmlErrorString
 *     _check_or_init_nvml()
 *     if __nvmlErrorString == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlErrorString is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":3969
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlErrorString is not found")
 *     return (<const char* (*)(nvmlReturn_t) noexcept nogil>__nvmlErrorString)(             # <<<<<<<<<<<<<<
 *         result)
 * 
*/
  __pyx_r = ((char const *(*)(nvmlReturn_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlErrorString)(__pyx_v_result);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":3963
 * 
 * 
 * cdef const char* _nvmlErrorString(nvmlReturn_t result) except?NULL nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlErrorString
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlErrorString", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":3973
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetDriverVersion(char* version, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetDriverVersion
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetDriverVersion(char *__pyx_v_version, unsigned int __pyx_v_length) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlSystemGetDriverVersion", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":3975
 * cdef nvmlReturn_t _nvmlSystemGetDriverVersion(char* version, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlSystemGetDriverVersion
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlSystemGetDriverVersion == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 3975, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":3976
 *     global __nvmlSystemGetDriverVersion
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetDriverVersion == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetDriverVersion is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetDriverVersion == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":3977
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetDriverVersion == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetDriverVersion is not found")
 *     return (<nvmlReturn_t (*)(char*, unsigned int) noexcept nogil>__nvmlSystemGetDriverVersion)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":3978
 *     if __nvmlSystemGetDriverVersion == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetDriverVersion is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(char*, unsigned int) noexcept nogil>__nvmlSystemGetDriverVersion)(
 *         version, length)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3978, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlSystemGetDriverVers};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3978, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 3978, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":3977
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetDriverVersion == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetDriverVersion is not found")
 *     return (<nvmlReturn_t (*)(char*, unsigned int) noexcept nogil>__nvmlSystemGetDriverVersion)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":3976
 *     global __nvmlSystemGetDriverVersion
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetDriverVersion == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetDriverVersion is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":3979
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetDriverVersion is not found")
 *     return (<nvmlReturn_t (*)(char*, unsigned int) noexcept nogil>__nvmlSystemGetDriverVersion)(             # <<<<<<<<<<<<<<
 *         version, length)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(char *, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetDriverVersion)(__pyx_v_version, __pyx_v_length);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":3973
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetDriverVersion(char* version, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetDriverVersion
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlSystemGetDriverVersion", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":3983
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetNVMLVersion(char* version, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetNVMLVersion
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetNVMLVersion(char *__pyx_v_version, unsigned int __pyx_v_length) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlSystemGetNVMLVersion", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":3985
 * cdef nvmlReturn_t _nvmlSystemGetNVMLVersion(char* version, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlSystemGetNVMLVersion
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlSystemGetNVMLVersion == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 3985, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":3986
 *     global __nvmlSystemGetNVMLVersion
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetNVMLVersion == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetNVMLVersion is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetNVMLVersion == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":3987
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetNVMLVersion == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetNVMLVersion is not found")
 *     return (<nvmlReturn_t (*)(char*, unsigned int) noexcept nogil>__nvmlSystemGetNVMLVersion)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":3988
 *     if __nvmlSystemGetNVMLVersion == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetNVMLVersion is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(char*, unsigned int) noexcept nogil>__nvmlSystemGetNVMLVersion)(
 *         version, length)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3988, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlSystemGetNVMLVersio};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3988, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 3988, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":3987
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetNVMLVersion == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetNVMLVersion is not found")
 *     return (<nvmlReturn_t (*)(char*, unsigned int) noexcept nogil>__nvmlSystemGetNVMLVersion)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":3986
 *     global __nvmlSystemGetNVMLVersion
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetNVMLVersion == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetNVMLVersion is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":3989
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetNVMLVersion is not found")
 *     return (<nvmlReturn_t (*)(char*, unsigned int) noexcept nogil>__nvmlSystemGetNVMLVersion)(             # <<<<<<<<<<<<<<
 *         version, length)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(char *, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetNVMLVersion)(__pyx_v_version, __pyx_v_length);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":3983
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetNVMLVersion(char* version, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetNVMLVersion
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlSystemGetNVMLVersion", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":3993
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetCudaDriverVersion(int* cudaDriverVersion) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetCudaDriverVersion
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetCudaDriverVersion(int *__pyx_v_cudaDriverVersion) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlSystemGetCudaDriverVersion", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":3995
 * cdef nvmlReturn_t _nvmlSystemGetCudaDriverVersion(int* cudaDriverVersion) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlSystemGetCudaDriverVersion
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlSystemGetCudaDriverVersion == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 3995, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":3996
 *     global __nvmlSystemGetCudaDriverVersion
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetCudaDriverVersion == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetCudaDriverVersion is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetCudaDriverVersion == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":3997
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetCudaDriverVersion == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetCudaDriverVersion is not found")
 *     return (<nvmlReturn_t (*)(int*) noexcept nogil>__nvmlSystemGetCudaDriverVersion)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":3998
 *     if __nvmlSystemGetCudaDriverVersion == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetCudaDriverVersion is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(int*) noexcept nogil>__nvmlSystemGetCudaDriverVersion)(
 *         cudaDriverVersion)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3998, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlSystemGetCudaDriver};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3998, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 3998, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":3997
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetCudaDriverVersion == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetCudaDriverVersion is not found")
 *     return (<nvmlReturn_t (*)(int*) noexcept nogil>__nvmlSystemGetCudaDriverVersion)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":3996
 *     global __nvmlSystemGetCudaDriverVersion
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetCudaDriverVersion == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetCudaDriverVersion is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":3999
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetCudaDriverVersion is not found")
 *     return (<nvmlReturn_t (*)(int*) noexcept nogil>__nvmlSystemGetCudaDriverVersion)(             # <<<<<<<<<<<<<<
 *         cudaDriverVersion)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetCudaDriverVersion)(__pyx_v_cudaDriverVersion);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":3993
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetCudaDriverVersion(int* cudaDriverVersion) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetCudaDriverVersion
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlSystemGetCudaDriverVersion", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4003
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetCudaDriverVersion_v2(int* cudaDriverVersion) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetCudaDriverVersion_v2
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetCudaDriverVersion_v2(int *__pyx_v_cudaDriverVersion) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlSystemGetCudaDriverVersion_v2", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4005
 * cdef nvmlReturn_t _nvmlSystemGetCudaDriverVersion_v2(int* cudaDriverVersion) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlSystemGetCudaDriverVersion_v2
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlSystemGetCudaDriverVersion_v2 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4005, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4006
 *     global __nvmlSystemGetCudaDriverVersion_v2
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetCudaDriverVersion_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetCudaDriverVersion_v2 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetCudaDriverVersion_v2 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4007
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetCudaDriverVersion_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetCudaDriverVersion_v2 is not found")
 *     return (<nvmlReturn_t (*)(int*) noexcept nogil>__nvmlSystemGetCudaDriverVersion_v2)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4008
 *     if __nvmlSystemGetCudaDriverVersion_v2 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetCudaDriverVersion_v2 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(int*) noexcept nogil>__nvmlSystemGetCudaDriverVersion_v2)(
 *         cudaDriverVersion)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4008, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlSystemGetCudaDriver_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4008, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4008, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4007
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetCudaDriverVersion_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetCudaDriverVersion_v2 is not found")
 *     return (<nvmlReturn_t (*)(int*) noexcept nogil>__nvmlSystemGetCudaDriverVersion_v2)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4006
 *     global __nvmlSystemGetCudaDriverVersion_v2
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetCudaDriverVersion_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetCudaDriverVersion_v2 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4009
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetCudaDriverVersion_v2 is not found")
 *     return (<nvmlReturn_t (*)(int*) noexcept nogil>__nvmlSystemGetCudaDriverVersion_v2)(             # <<<<<<<<<<<<<<
 *         cudaDriverVersion)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetCudaDriverVersion_v2)(__pyx_v_cudaDriverVersion);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4003
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetCudaDriverVersion_v2(int* cudaDriverVersion) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetCudaDriverVersion_v2
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlSystemGetCudaDriverVersion_v2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4013
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetProcessName(unsigned int pid, char* name, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetProcessName
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetProcessName(unsigned int __pyx_v_pid, char *__pyx_v_name, unsigned int __pyx_v_length) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlSystemGetProcessName", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4015
 * cdef nvmlReturn_t _nvmlSystemGetProcessName(unsigned int pid, char* name, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlSystemGetProcessName
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlSystemGetProcessName == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4015, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4016
 *     global __nvmlSystemGetProcessName
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetProcessName == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetProcessName is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetProcessName == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4017
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetProcessName == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetProcessName is not found")
 *     return (<nvmlReturn_t (*)(unsigned int, char*, unsigned int) noexcept nogil>__nvmlSystemGetProcessName)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4018
 *     if __nvmlSystemGetProcessName == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetProcessName is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(unsigned int, char*, unsigned int) noexcept nogil>__nvmlSystemGetProcessName)(
 *         pid, name, length)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4018, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlSystemGetProcessNam};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4018, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4018, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4017
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetProcessName == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetProcessName is not found")
 *     return (<nvmlReturn_t (*)(unsigned int, char*, unsigned int) noexcept nogil>__nvmlSystemGetProcessName)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4016
 *     global __nvmlSystemGetProcessName
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetProcessName == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetProcessName is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4019
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetProcessName is not found")
 *     return (<nvmlReturn_t (*)(unsigned int, char*, unsigned int) noexcept nogil>__nvmlSystemGetProcessName)(             # <<<<<<<<<<<<<<
 *         pid, name, length)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(unsigned int, char *, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetProcessName)(__pyx_v_pid, __pyx_v_name, __pyx_v_length);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4013
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetProcessName(unsigned int pid, char* name, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetProcessName
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlSystemGetProcessName", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4023
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetHicVersion(unsigned int* hwbcCount, nvmlHwbcEntry_t* hwbcEntries) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetHicVersion
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetHicVersion(unsigned int *__pyx_v_hwbcCount, nvmlHwbcEntry_t *__pyx_v_hwbcEntries) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlSystemGetHicVersion", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4025
 * cdef nvmlReturn_t _nvmlSystemGetHicVersion(unsigned int* hwbcCount, nvmlHwbcEntry_t* hwbcEntries) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlSystemGetHicVersion
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlSystemGetHicVersion == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4025, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4026
 *     global __nvmlSystemGetHicVersion
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetHicVersion == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetHicVersion is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetHicVersion == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4027
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetHicVersion == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetHicVersion is not found")
 *     return (<nvmlReturn_t (*)(unsigned int*, nvmlHwbcEntry_t*) noexcept nogil>__nvmlSystemGetHicVersion)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4028
 *     if __nvmlSystemGetHicVersion == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetHicVersion is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(unsigned int*, nvmlHwbcEntry_t*) noexcept nogil>__nvmlSystemGetHicVersion)(
 *         hwbcCount, hwbcEntries)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4028, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlSystemGetHicVersion};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4028, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4028, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4027
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetHicVersion == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetHicVersion is not found")
 *     return (<nvmlReturn_t (*)(unsigned int*, nvmlHwbcEntry_t*) noexcept nogil>__nvmlSystemGetHicVersion)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4026
 *     global __nvmlSystemGetHicVersion
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetHicVersion == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetHicVersion is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4029
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetHicVersion is not found")
 *     return (<nvmlReturn_t (*)(unsigned int*, nvmlHwbcEntry_t*) noexcept nogil>__nvmlSystemGetHicVersion)(             # <<<<<<<<<<<<<<
 *         hwbcCount, hwbcEntries)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(unsigned int *, nvmlHwbcEntry_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetHicVersion)(__pyx_v_hwbcCount, __pyx_v_hwbcEntries);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4023
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetHicVersion(unsigned int* hwbcCount, nvmlHwbcEntry_t* hwbcEntries) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetHicVersion
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlSystemGetHicVersion", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4033
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetTopologyGpuSet(unsigned int cpuNumber, unsigned int* count, nvmlDevice_t* deviceArray) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetTopologyGpuSet
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetTopologyGpuSet(unsigned int __pyx_v_cpuNumber, unsigned int *__pyx_v_count, nvmlDevice_t *__pyx_v_deviceArray) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlSystemGetTopologyGpuSet", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4035
 * cdef nvmlReturn_t _nvmlSystemGetTopologyGpuSet(unsigned int cpuNumber, unsigned int* count, nvmlDevice_t* deviceArray) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlSystemGetTopologyGpuSet
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlSystemGetTopologyGpuSet == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4035, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4036
 *     global __nvmlSystemGetTopologyGpuSet
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetTopologyGpuSet == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetTopologyGpuSet is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetTopologyGpuSet == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4037
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetTopologyGpuSet == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetTopologyGpuSet is not found")
 *     return (<nvmlReturn_t (*)(unsigned int, unsigned int*, nvmlDevice_t*) noexcept nogil>__nvmlSystemGetTopologyGpuSet)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4038
 *     if __nvmlSystemGetTopologyGpuSet == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetTopologyGpuSet is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(unsigned int, unsigned int*, nvmlDevice_t*) noexcept nogil>__nvmlSystemGetTopologyGpuSet)(
 *         cpuNumber, count, deviceArray)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4038, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlSystemGetTopologyGp};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4038, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4038, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4037
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetTopologyGpuSet == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetTopologyGpuSet is not found")
 *     return (<nvmlReturn_t (*)(unsigned int, unsigned int*, nvmlDevice_t*) noexcept nogil>__nvmlSystemGetTopologyGpuSet)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4036
 *     global __nvmlSystemGetTopologyGpuSet
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetTopologyGpuSet == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetTopologyGpuSet is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4039
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetTopologyGpuSet is not found")
 *     return (<nvmlReturn_t (*)(unsigned int, unsigned int*, nvmlDevice_t*) noexcept nogil>__nvmlSystemGetTopologyGpuSet)(             # <<<<<<<<<<<<<<
 *         cpuNumber, count, deviceArray)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(unsigned int, unsigned int *, nvmlDevice_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetTopologyGpuSet)(__pyx_v_cpuNumber, __pyx_v_count, __pyx_v_deviceArray);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4033
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetTopologyGpuSet(unsigned int cpuNumber, unsigned int* count, nvmlDevice_t* deviceArray) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetTopologyGpuSet
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlSystemGetTopologyGpuSet", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4043
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetDriverBranch(nvmlSystemDriverBranchInfo_t* branchInfo, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetDriverBranch
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetDriverBranch(nvmlSystemDriverBranchInfo_t *__pyx_v_branchInfo, unsigned int __pyx_v_length) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlSystemGetDriverBranch", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4045
 * cdef nvmlReturn_t _nvmlSystemGetDriverBranch(nvmlSystemDriverBranchInfo_t* branchInfo, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlSystemGetDriverBranch
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlSystemGetDriverBranch == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4045, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4046
 *     global __nvmlSystemGetDriverBranch
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetDriverBranch == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetDriverBranch is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetDriverBranch == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4047
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetDriverBranch == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetDriverBranch is not found")
 *     return (<nvmlReturn_t (*)(nvmlSystemDriverBranchInfo_t*, unsigned int) noexcept nogil>__nvmlSystemGetDriverBranch)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4048
 *     if __nvmlSystemGetDriverBranch == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetDriverBranch is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlSystemDriverBranchInfo_t*, unsigned int) noexcept nogil>__nvmlSystemGetDriverBranch)(
 *         branchInfo, length)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4048, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlSystemGetDriverBran};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4048, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4048, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4047
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetDriverBranch == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetDriverBranch is not found")
 *     return (<nvmlReturn_t (*)(nvmlSystemDriverBranchInfo_t*, unsigned int) noexcept nogil>__nvmlSystemGetDriverBranch)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4046
 *     global __nvmlSystemGetDriverBranch
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetDriverBranch == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetDriverBranch is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4049
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetDriverBranch is not found")
 *     return (<nvmlReturn_t (*)(nvmlSystemDriverBranchInfo_t*, unsigned int) noexcept nogil>__nvmlSystemGetDriverBranch)(             # <<<<<<<<<<<<<<
 *         branchInfo, length)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlSystemDriverBranchInfo_t *, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetDriverBranch)(__pyx_v_branchInfo, __pyx_v_length);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4043
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetDriverBranch(nvmlSystemDriverBranchInfo_t* branchInfo, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetDriverBranch
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlSystemGetDriverBranch", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4053
 * 
 * 
 * cdef nvmlReturn_t _nvmlUnitGetCount(unsigned int* unitCount) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlUnitGetCount
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlUnitGetCount(unsigned int *__pyx_v_unitCount) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlUnitGetCount", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4055
 * cdef nvmlReturn_t _nvmlUnitGetCount(unsigned int* unitCount) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlUnitGetCount
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlUnitGetCount == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4055, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4056
 *     global __nvmlUnitGetCount
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetCount == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetCount is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetCount == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4057
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetCount == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlUnitGetCount is not found")
 *     return (<nvmlReturn_t (*)(unsigned int*) noexcept nogil>__nvmlUnitGetCount)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4058
 *     if __nvmlUnitGetCount == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetCount is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(unsigned int*) noexcept nogil>__nvmlUnitGetCount)(
 *         unitCount)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4058, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlUnitGetCount_is_not};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4058, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4058, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4057
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetCount == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlUnitGetCount is not found")
 *     return (<nvmlReturn_t (*)(unsigned int*) noexcept nogil>__nvmlUnitGetCount)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4056
 *     global __nvmlUnitGetCount
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetCount == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetCount is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4059
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetCount is not found")
 *     return (<nvmlReturn_t (*)(unsigned int*) noexcept nogil>__nvmlUnitGetCount)(             # <<<<<<<<<<<<<<
 *         unitCount)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetCount)(__pyx_v_unitCount);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4053
 * 
 * 
 * cdef nvmlReturn_t _nvmlUnitGetCount(unsigned int* unitCount) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlUnitGetCount
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlUnitGetCount", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4063
 * 
 * 
 * cdef nvmlReturn_t _nvmlUnitGetHandleByIndex(unsigned int index, nvmlUnit_t* unit) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlUnitGetHandleByIndex
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlUnitGetHandleByIndex(unsigned int __pyx_v_index, nvmlUnit_t *__pyx_v_unit) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlUnitGetHandleByIndex", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4065
 * cdef nvmlReturn_t _nvmlUnitGetHandleByIndex(unsigned int index, nvmlUnit_t* unit) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlUnitGetHandleByIndex
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlUnitGetHandleByIndex == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4065, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4066
 *     global __nvmlUnitGetHandleByIndex
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetHandleByIndex == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetHandleByIndex is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetHandleByIndex == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4067
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetHandleByIndex == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlUnitGetHandleByIndex is not found")
 *     return (<nvmlReturn_t (*)(unsigned int, nvmlUnit_t*) noexcept nogil>__nvmlUnitGetHandleByIndex)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4068
 *     if __nvmlUnitGetHandleByIndex == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetHandleByIndex is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(unsigned int, nvmlUnit_t*) noexcept nogil>__nvmlUnitGetHandleByIndex)(
 *         index, unit)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4068, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlUnitGetHandleByInde};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4068, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4068, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4067
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetHandleByIndex == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlUnitGetHandleByIndex is not found")
 *     return (<nvmlReturn_t (*)(unsigned int, nvmlUnit_t*) noexcept nogil>__nvmlUnitGetHandleByIndex)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4066
 *     global __nvmlUnitGetHandleByIndex
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetHandleByIndex == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetHandleByIndex is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4069
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetHandleByIndex is not found")
 *     return (<nvmlReturn_t (*)(unsigned int, nvmlUnit_t*) noexcept nogil>__nvmlUnitGetHandleByIndex)(             # <<<<<<<<<<<<<<
 *         index, unit)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(unsigned int, nvmlUnit_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetHandleByIndex)(__pyx_v_index, __pyx_v_unit);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4063
 * 
 * 
 * cdef nvmlReturn_t _nvmlUnitGetHandleByIndex(unsigned int index, nvmlUnit_t* unit) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlUnitGetHandleByIndex
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlUnitGetHandleByIndex", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4073
 * 
 * 
 * cdef nvmlReturn_t _nvmlUnitGetUnitInfo(nvmlUnit_t unit, nvmlUnitInfo_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlUnitGetUnitInfo
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlUnitGetUnitInfo(nvmlUnit_t __pyx_v_unit, nvmlUnitInfo_t *__pyx_v_info) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlUnitGetUnitInfo", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4075
 * cdef nvmlReturn_t _nvmlUnitGetUnitInfo(nvmlUnit_t unit, nvmlUnitInfo_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlUnitGetUnitInfo
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlUnitGetUnitInfo == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4075, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4076
 *     global __nvmlUnitGetUnitInfo
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetUnitInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetUnitInfo is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetUnitInfo == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4077
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetUnitInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlUnitGetUnitInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, nvmlUnitInfo_t*) noexcept nogil>__nvmlUnitGetUnitInfo)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4078
 *     if __nvmlUnitGetUnitInfo == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetUnitInfo is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, nvmlUnitInfo_t*) noexcept nogil>__nvmlUnitGetUnitInfo)(
 *         unit, info)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4078, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlUnitGetUnitInfo_is};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4078, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4078, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4077
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetUnitInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlUnitGetUnitInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, nvmlUnitInfo_t*) noexcept nogil>__nvmlUnitGetUnitInfo)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4076
 *     global __nvmlUnitGetUnitInfo
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetUnitInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetUnitInfo is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4079
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetUnitInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, nvmlUnitInfo_t*) noexcept nogil>__nvmlUnitGetUnitInfo)(             # <<<<<<<<<<<<<<
 *         unit, info)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlUnit_t, nvmlUnitInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetUnitInfo)(__pyx_v_unit, __pyx_v_info);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4073
 * 
 * 
 * cdef nvmlReturn_t _nvmlUnitGetUnitInfo(nvmlUnit_t unit, nvmlUnitInfo_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlUnitGetUnitInfo
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlUnitGetUnitInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4083
 * 
 * 
 * cdef nvmlReturn_t _nvmlUnitGetLedState(nvmlUnit_t unit, nvmlLedState_t* state) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlUnitGetLedState
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlUnitGetLedState(nvmlUnit_t __pyx_v_unit, nvmlLedState_t *__pyx_v_state) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlUnitGetLedState", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4085
 * cdef nvmlReturn_t _nvmlUnitGetLedState(nvmlUnit_t unit, nvmlLedState_t* state) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlUnitGetLedState
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlUnitGetLedState == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4085, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4086
 *     global __nvmlUnitGetLedState
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetLedState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetLedState is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetLedState == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4087
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetLedState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlUnitGetLedState is not found")
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, nvmlLedState_t*) noexcept nogil>__nvmlUnitGetLedState)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4088
 *     if __nvmlUnitGetLedState == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetLedState is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, nvmlLedState_t*) noexcept nogil>__nvmlUnitGetLedState)(
 *         unit, state)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4088, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlUnitGetLedState_is};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4088, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4088, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4087
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetLedState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlUnitGetLedState is not found")
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, nvmlLedState_t*) noexcept nogil>__nvmlUnitGetLedState)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4086
 *     global __nvmlUnitGetLedState
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetLedState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetLedState is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4089
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetLedState is not found")
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, nvmlLedState_t*) noexcept nogil>__nvmlUnitGetLedState)(             # <<<<<<<<<<<<<<
 *         unit, state)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlUnit_t, nvmlLedState_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetLedState)(__pyx_v_unit, __pyx_v_state);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4083
 * 
 * 
 * cdef nvmlReturn_t _nvmlUnitGetLedState(nvmlUnit_t unit, nvmlLedState_t* state) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlUnitGetLedState
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlUnitGetLedState", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4093
 * 
 * 
 * cdef nvmlReturn_t _nvmlUnitGetPsuInfo(nvmlUnit_t unit, nvmlPSUInfo_t* psu) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlUnitGetPsuInfo
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlUnitGetPsuInfo(nvmlUnit_t __pyx_v_unit, nvmlPSUInfo_t *__pyx_v_psu) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlUnitGetPsuInfo", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4095
 * cdef nvmlReturn_t _nvmlUnitGetPsuInfo(nvmlUnit_t unit, nvmlPSUInfo_t* psu) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlUnitGetPsuInfo
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlUnitGetPsuInfo == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4095, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4096
 *     global __nvmlUnitGetPsuInfo
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetPsuInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetPsuInfo is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetPsuInfo == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4097
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetPsuInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlUnitGetPsuInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, nvmlPSUInfo_t*) noexcept nogil>__nvmlUnitGetPsuInfo)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4098
 *     if __nvmlUnitGetPsuInfo == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetPsuInfo is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, nvmlPSUInfo_t*) noexcept nogil>__nvmlUnitGetPsuInfo)(
 *         unit, psu)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4098, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlUnitGetPsuInfo_is_n};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4098, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4098, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4097
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetPsuInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlUnitGetPsuInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, nvmlPSUInfo_t*) noexcept nogil>__nvmlUnitGetPsuInfo)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4096
 *     global __nvmlUnitGetPsuInfo
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetPsuInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetPsuInfo is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4099
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetPsuInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, nvmlPSUInfo_t*) noexcept nogil>__nvmlUnitGetPsuInfo)(             # <<<<<<<<<<<<<<
 *         unit, psu)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlUnit_t, nvmlPSUInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetPsuInfo)(__pyx_v_unit, __pyx_v_psu);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4093
 * 
 * 
 * cdef nvmlReturn_t _nvmlUnitGetPsuInfo(nvmlUnit_t unit, nvmlPSUInfo_t* psu) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlUnitGetPsuInfo
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlUnitGetPsuInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4103
 * 
 * 
 * cdef nvmlReturn_t _nvmlUnitGetTemperature(nvmlUnit_t unit, unsigned int type, unsigned int* temp) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlUnitGetTemperature
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlUnitGetTemperature(nvmlUnit_t __pyx_v_unit, unsigned int __pyx_v_type, unsigned int *__pyx_v_temp) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlUnitGetTemperature", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4105
 * cdef nvmlReturn_t _nvmlUnitGetTemperature(nvmlUnit_t unit, unsigned int type, unsigned int* temp) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlUnitGetTemperature
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlUnitGetTemperature == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4105, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4106
 *     global __nvmlUnitGetTemperature
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetTemperature == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetTemperature is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetTemperature == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4107
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetTemperature == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlUnitGetTemperature is not found")
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, unsigned int, unsigned int*) noexcept nogil>__nvmlUnitGetTemperature)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4108
 *     if __nvmlUnitGetTemperature == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetTemperature is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, unsigned int, unsigned int*) noexcept nogil>__nvmlUnitGetTemperature)(
 *         unit, type, temp)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4108, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlUnitGetTemperature};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4108, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4108, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4107
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetTemperature == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlUnitGetTemperature is not found")
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, unsigned int, unsigned int*) noexcept nogil>__nvmlUnitGetTemperature)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4106
 *     global __nvmlUnitGetTemperature
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetTemperature == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetTemperature is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4109
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetTemperature is not found")
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, unsigned int, unsigned int*) noexcept nogil>__nvmlUnitGetTemperature)(             # <<<<<<<<<<<<<<
 *         unit, type, temp)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlUnit_t, unsigned int, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetTemperature)(__pyx_v_unit, __pyx_v_type, __pyx_v_temp);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4103
 * 
 * 
 * cdef nvmlReturn_t _nvmlUnitGetTemperature(nvmlUnit_t unit, unsigned int type, unsigned int* temp) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlUnitGetTemperature
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlUnitGetTemperature", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4113
 * 
 * 
 * cdef nvmlReturn_t _nvmlUnitGetFanSpeedInfo(nvmlUnit_t unit, nvmlUnitFanSpeeds_t* fanSpeeds) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlUnitGetFanSpeedInfo
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlUnitGetFanSpeedInfo(nvmlUnit_t __pyx_v_unit, nvmlUnitFanSpeeds_t *__pyx_v_fanSpeeds) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlUnitGetFanSpeedInfo", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4115
 * cdef nvmlReturn_t _nvmlUnitGetFanSpeedInfo(nvmlUnit_t unit, nvmlUnitFanSpeeds_t* fanSpeeds) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlUnitGetFanSpeedInfo
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlUnitGetFanSpeedInfo == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4115, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4116
 *     global __nvmlUnitGetFanSpeedInfo
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetFanSpeedInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetFanSpeedInfo is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetFanSpeedInfo == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4117
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetFanSpeedInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlUnitGetFanSpeedInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, nvmlUnitFanSpeeds_t*) noexcept nogil>__nvmlUnitGetFanSpeedInfo)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4118
 *     if __nvmlUnitGetFanSpeedInfo == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetFanSpeedInfo is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, nvmlUnitFanSpeeds_t*) noexcept nogil>__nvmlUnitGetFanSpeedInfo)(
 *         unit, fanSpeeds)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4118, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlUnitGetFanSpeedInfo};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4118, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4118, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4117
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetFanSpeedInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlUnitGetFanSpeedInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, nvmlUnitFanSpeeds_t*) noexcept nogil>__nvmlUnitGetFanSpeedInfo)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4116
 *     global __nvmlUnitGetFanSpeedInfo
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetFanSpeedInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetFanSpeedInfo is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4119
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetFanSpeedInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, nvmlUnitFanSpeeds_t*) noexcept nogil>__nvmlUnitGetFanSpeedInfo)(             # <<<<<<<<<<<<<<
 *         unit, fanSpeeds)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlUnit_t, nvmlUnitFanSpeeds_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetFanSpeedInfo)(__pyx_v_unit, __pyx_v_fanSpeeds);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4113
 * 
 * 
 * cdef nvmlReturn_t _nvmlUnitGetFanSpeedInfo(nvmlUnit_t unit, nvmlUnitFanSpeeds_t* fanSpeeds) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlUnitGetFanSpeedInfo
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlUnitGetFanSpeedInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4123
 * 
 * 
 * cdef nvmlReturn_t _nvmlUnitGetDevices(nvmlUnit_t unit, unsigned int* deviceCount, nvmlDevice_t* devices) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlUnitGetDevices
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlUnitGetDevices(nvmlUnit_t __pyx_v_unit, unsigned int *__pyx_v_deviceCount, nvmlDevice_t *__pyx_v_devices) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlUnitGetDevices", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4125
 * cdef nvmlReturn_t _nvmlUnitGetDevices(nvmlUnit_t unit, unsigned int* deviceCount, nvmlDevice_t* devices) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlUnitGetDevices
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlUnitGetDevices == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4125, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4126
 *     global __nvmlUnitGetDevices
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetDevices == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetDevices is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetDevices == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4127
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetDevices == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlUnitGetDevices is not found")
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, unsigned int*, nvmlDevice_t*) noexcept nogil>__nvmlUnitGetDevices)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4128
 *     if __nvmlUnitGetDevices == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetDevices is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, unsigned int*, nvmlDevice_t*) noexcept nogil>__nvmlUnitGetDevices)(
 *         unit, deviceCount, devices)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4128, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlUnitGetDevices_is_n};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4128, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4128, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4127
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetDevices == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlUnitGetDevices is not found")
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, unsigned int*, nvmlDevice_t*) noexcept nogil>__nvmlUnitGetDevices)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4126
 *     global __nvmlUnitGetDevices
 *     _check_or_init_nvml()
 *     if __nvmlUnitGetDevices == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetDevices is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4129
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitGetDevices is not found")
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, unsigned int*, nvmlDevice_t*) noexcept nogil>__nvmlUnitGetDevices)(             # <<<<<<<<<<<<<<
 *         unit, deviceCount, devices)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlUnit_t, unsigned int *, nvmlDevice_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetDevices)(__pyx_v_unit, __pyx_v_deviceCount, __pyx_v_devices);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4123
 * 
 * 
 * cdef nvmlReturn_t _nvmlUnitGetDevices(nvmlUnit_t unit, unsigned int* deviceCount, nvmlDevice_t* devices) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlUnitGetDevices
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlUnitGetDevices", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4133
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetCount_v2(unsigned int* deviceCount) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetCount_v2
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetCount_v2(unsigned int *__pyx_v_deviceCount) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetCount_v2", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4135
 * cdef nvmlReturn_t _nvmlDeviceGetCount_v2(unsigned int* deviceCount) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetCount_v2
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetCount_v2 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4135, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4136
 *     global __nvmlDeviceGetCount_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCount_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCount_v2 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCount_v2 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4137
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCount_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetCount_v2 is not found")
 *     return (<nvmlReturn_t (*)(unsigned int*) noexcept nogil>__nvmlDeviceGetCount_v2)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4138
 *     if __nvmlDeviceGetCount_v2 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCount_v2 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(unsigned int*) noexcept nogil>__nvmlDeviceGetCount_v2)(
 *         deviceCount)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4138, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetCount_v2_i};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4138, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4138, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4137
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCount_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetCount_v2 is not found")
 *     return (<nvmlReturn_t (*)(unsigned int*) noexcept nogil>__nvmlDeviceGetCount_v2)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4136
 *     global __nvmlDeviceGetCount_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCount_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCount_v2 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4139
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCount_v2 is not found")
 *     return (<nvmlReturn_t (*)(unsigned int*) noexcept nogil>__nvmlDeviceGetCount_v2)(             # <<<<<<<<<<<<<<
 *         deviceCount)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCount_v2)(__pyx_v_deviceCount);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4133
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetCount_v2(unsigned int* deviceCount) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetCount_v2
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetCount_v2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4143
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetAttributes_v2(nvmlDevice_t device, nvmlDeviceAttributes_t* attributes) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetAttributes_v2
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetAttributes_v2(nvmlDevice_t __pyx_v_device, nvmlDeviceAttributes_t *__pyx_v_attributes) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetAttributes_v2", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4145
 * cdef nvmlReturn_t _nvmlDeviceGetAttributes_v2(nvmlDevice_t device, nvmlDeviceAttributes_t* attributes) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetAttributes_v2
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetAttributes_v2 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4145, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4146
 *     global __nvmlDeviceGetAttributes_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAttributes_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAttributes_v2 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAttributes_v2 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4147
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAttributes_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetAttributes_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceAttributes_t*) noexcept nogil>__nvmlDeviceGetAttributes_v2)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4148
 *     if __nvmlDeviceGetAttributes_v2 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAttributes_v2 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceAttributes_t*) noexcept nogil>__nvmlDeviceGetAttributes_v2)(
 *         device, attributes)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4148, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetAttributes};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4148, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4148, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4147
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAttributes_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetAttributes_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceAttributes_t*) noexcept nogil>__nvmlDeviceGetAttributes_v2)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4146
 *     global __nvmlDeviceGetAttributes_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAttributes_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAttributes_v2 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4149
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAttributes_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceAttributes_t*) noexcept nogil>__nvmlDeviceGetAttributes_v2)(             # <<<<<<<<<<<<<<
 *         device, attributes)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceAttributes_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAttributes_v2)(__pyx_v_device, __pyx_v_attributes);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4143
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetAttributes_v2(nvmlDevice_t device, nvmlDeviceAttributes_t* attributes) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetAttributes_v2
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetAttributes_v2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4153
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetHandleByIndex_v2(unsigned int index, nvmlDevice_t* device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetHandleByIndex_v2
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetHandleByIndex_v2(unsigned int __pyx_v_index, nvmlDevice_t *__pyx_v_device) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetHandleByIndex_v2", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4155
 * cdef nvmlReturn_t _nvmlDeviceGetHandleByIndex_v2(unsigned int index, nvmlDevice_t* device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetHandleByIndex_v2
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetHandleByIndex_v2 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4155, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4156
 *     global __nvmlDeviceGetHandleByIndex_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHandleByIndex_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleByIndex_v2 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByIndex_v2 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4157
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHandleByIndex_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleByIndex_v2 is not found")
 *     return (<nvmlReturn_t (*)(unsigned int, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetHandleByIndex_v2)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4158
 *     if __nvmlDeviceGetHandleByIndex_v2 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleByIndex_v2 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(unsigned int, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetHandleByIndex_v2)(
 *         index, device)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4158, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetHandleByIn};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4158, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4158, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4157
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHandleByIndex_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleByIndex_v2 is not found")
 *     return (<nvmlReturn_t (*)(unsigned int, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetHandleByIndex_v2)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4156
 *     global __nvmlDeviceGetHandleByIndex_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHandleByIndex_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleByIndex_v2 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4159
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleByIndex_v2 is not found")
 *     return (<nvmlReturn_t (*)(unsigned int, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetHandleByIndex_v2)(             # <<<<<<<<<<<<<<
 *         index, device)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(unsigned int, nvmlDevice_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByIndex_v2)(__pyx_v_index, __pyx_v_device);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4153
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetHandleByIndex_v2(unsigned int index, nvmlDevice_t* device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetHandleByIndex_v2
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetHandleByIndex_v2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4163
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetHandleBySerial(const char* serial, nvmlDevice_t* device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetHandleBySerial
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetHandleBySerial(char const *__pyx_v_serial, nvmlDevice_t *__pyx_v_device) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetHandleBySerial", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4165
 * cdef nvmlReturn_t _nvmlDeviceGetHandleBySerial(const char* serial, nvmlDevice_t* device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetHandleBySerial
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetHandleBySerial == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4165, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4166
 *     global __nvmlDeviceGetHandleBySerial
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHandleBySerial == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleBySerial is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleBySerial == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4167
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHandleBySerial == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleBySerial is not found")
 *     return (<nvmlReturn_t (*)(const char*, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetHandleBySerial)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4168
 *     if __nvmlDeviceGetHandleBySerial == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleBySerial is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(const char*, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetHandleBySerial)(
 *         serial, device)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4168, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetHandleBySe};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4168, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4168, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4167
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHandleBySerial == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleBySerial is not found")
 *     return (<nvmlReturn_t (*)(const char*, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetHandleBySerial)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4166
 *     global __nvmlDeviceGetHandleBySerial
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHandleBySerial == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleBySerial is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4169
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleBySerial is not found")
 *     return (<nvmlReturn_t (*)(const char*, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetHandleBySerial)(             # <<<<<<<<<<<<<<
 *         serial, device)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(char const *, nvmlDevice_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleBySerial)(__pyx_v_serial, __pyx_v_device);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4163
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetHandleBySerial(const char* serial, nvmlDevice_t* device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetHandleBySerial
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetHandleBySerial", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4173
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetHandleByUUID(const char* uuid, nvmlDevice_t* device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetHandleByUUID
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetHandleByUUID(char const *__pyx_v_uuid, nvmlDevice_t *__pyx_v_device) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetHandleByUUID", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4175
 * cdef nvmlReturn_t _nvmlDeviceGetHandleByUUID(const char* uuid, nvmlDevice_t* device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetHandleByUUID
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetHandleByUUID == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4175, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4176
 *     global __nvmlDeviceGetHandleByUUID
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHandleByUUID == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleByUUID is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByUUID == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4177
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHandleByUUID == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleByUUID is not found")
 *     return (<nvmlReturn_t (*)(const char*, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetHandleByUUID)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4178
 *     if __nvmlDeviceGetHandleByUUID == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleByUUID is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(const char*, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetHandleByUUID)(
 *         uuid, device)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4178, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetHandleByUU};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4178, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4178, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4177
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHandleByUUID == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleByUUID is not found")
 *     return (<nvmlReturn_t (*)(const char*, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetHandleByUUID)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4176
 *     global __nvmlDeviceGetHandleByUUID
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHandleByUUID == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleByUUID is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4179
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleByUUID is not found")
 *     return (<nvmlReturn_t (*)(const char*, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetHandleByUUID)(             # <<<<<<<<<<<<<<
 *         uuid, device)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(char const *, nvmlDevice_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByUUID)(__pyx_v_uuid, __pyx_v_device);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4173
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetHandleByUUID(const char* uuid, nvmlDevice_t* device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetHandleByUUID
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetHandleByUUID", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4183
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetHandleByUUIDV(const nvmlUUID_t* uuid, nvmlDevice_t* device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetHandleByUUIDV
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetHandleByUUIDV(nvmlUUID_t const *__pyx_v_uuid, nvmlDevice_t *__pyx_v_device) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetHandleByUUIDV", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4185
 * cdef nvmlReturn_t _nvmlDeviceGetHandleByUUIDV(const nvmlUUID_t* uuid, nvmlDevice_t* device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetHandleByUUIDV
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetHandleByUUIDV == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4185, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4186
 *     global __nvmlDeviceGetHandleByUUIDV
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHandleByUUIDV == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleByUUIDV is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByUUIDV == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4187
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHandleByUUIDV == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleByUUIDV is not found")
 *     return (<nvmlReturn_t (*)(const nvmlUUID_t*, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetHandleByUUIDV)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4188
 *     if __nvmlDeviceGetHandleByUUIDV == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleByUUIDV is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(const nvmlUUID_t*, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetHandleByUUIDV)(
 *         uuid, device)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4188, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetHandleByUU_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4188, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4188, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4187
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHandleByUUIDV == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleByUUIDV is not found")
 *     return (<nvmlReturn_t (*)(const nvmlUUID_t*, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetHandleByUUIDV)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4186
 *     global __nvmlDeviceGetHandleByUUIDV
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHandleByUUIDV == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleByUUIDV is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4189
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleByUUIDV is not found")
 *     return (<nvmlReturn_t (*)(const nvmlUUID_t*, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetHandleByUUIDV)(             # <<<<<<<<<<<<<<
 *         uuid, device)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlUUID_t const *, nvmlDevice_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByUUIDV)(__pyx_v_uuid, __pyx_v_device);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4183
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetHandleByUUIDV(const nvmlUUID_t* uuid, nvmlDevice_t* device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetHandleByUUIDV
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetHandleByUUIDV", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4193
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetHandleByPciBusId_v2(const char* pciBusId, nvmlDevice_t* device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetHandleByPciBusId_v2
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetHandleByPciBusId_v2(char const *__pyx_v_pciBusId, nvmlDevice_t *__pyx_v_device) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetHandleByPciBusId_v2", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4195
 * cdef nvmlReturn_t _nvmlDeviceGetHandleByPciBusId_v2(const char* pciBusId, nvmlDevice_t* device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetHandleByPciBusId_v2
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetHandleByPciBusId_v2 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4195, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4196
 *     global __nvmlDeviceGetHandleByPciBusId_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHandleByPciBusId_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleByPciBusId_v2 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByPciBusId_v2 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4197
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHandleByPciBusId_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleByPciBusId_v2 is not found")
 *     return (<nvmlReturn_t (*)(const char*, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetHandleByPciBusId_v2)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4198
 *     if __nvmlDeviceGetHandleByPciBusId_v2 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleByPciBusId_v2 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(const char*, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetHandleByPciBusId_v2)(
 *         pciBusId, device)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4198, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetHandleByPc};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4198, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4198, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4197
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHandleByPciBusId_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleByPciBusId_v2 is not found")
 *     return (<nvmlReturn_t (*)(const char*, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetHandleByPciBusId_v2)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4196
 *     global __nvmlDeviceGetHandleByPciBusId_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHandleByPciBusId_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleByPciBusId_v2 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4199
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHandleByPciBusId_v2 is not found")
 *     return (<nvmlReturn_t (*)(const char*, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetHandleByPciBusId_v2)(             # <<<<<<<<<<<<<<
 *         pciBusId, device)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(char const *, nvmlDevice_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByPciBusId_v2)(__pyx_v_pciBusId, __pyx_v_device);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4193
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetHandleByPciBusId_v2(const char* pciBusId, nvmlDevice_t* device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetHandleByPciBusId_v2
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetHandleByPciBusId_v2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4203
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetName(nvmlDevice_t device, char* name, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetName
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetName(nvmlDevice_t __pyx_v_device, char *__pyx_v_name, unsigned int __pyx_v_length) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetName", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4205
 * cdef nvmlReturn_t _nvmlDeviceGetName(nvmlDevice_t device, char* name, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetName
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetName == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4205, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4206
 *     global __nvmlDeviceGetName
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetName == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetName is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetName == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4207
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetName == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetName is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetName)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4208
 *     if __nvmlDeviceGetName == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetName is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetName)(
 *         device, name, length)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4208, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetName_is_no};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4208, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4208, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4207
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetName == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetName is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetName)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4206
 *     global __nvmlDeviceGetName
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetName == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetName is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4209
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetName is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetName)(             # <<<<<<<<<<<<<<
 *         device, name, length)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, char *, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetName)(__pyx_v_device, __pyx_v_name, __pyx_v_length);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4203
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetName(nvmlDevice_t device, char* name, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetName
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetName", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4213
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetBrand(nvmlDevice_t device, nvmlBrandType_t* type) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetBrand
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetBrand(nvmlDevice_t __pyx_v_device, nvmlBrandType_t *__pyx_v_type) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetBrand", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4215
 * cdef nvmlReturn_t _nvmlDeviceGetBrand(nvmlDevice_t device, nvmlBrandType_t* type) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetBrand
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetBrand == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4215, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4216
 *     global __nvmlDeviceGetBrand
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetBrand == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetBrand is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBrand == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4217
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetBrand == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetBrand is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlBrandType_t*) noexcept nogil>__nvmlDeviceGetBrand)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4218
 *     if __nvmlDeviceGetBrand == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetBrand is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlBrandType_t*) noexcept nogil>__nvmlDeviceGetBrand)(
 *         device, type)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4218, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetBrand_is_n};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4218, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4218, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4217
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetBrand == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetBrand is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlBrandType_t*) noexcept nogil>__nvmlDeviceGetBrand)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4216
 *     global __nvmlDeviceGetBrand
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetBrand == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetBrand is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4219
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetBrand is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlBrandType_t*) noexcept nogil>__nvmlDeviceGetBrand)(             # <<<<<<<<<<<<<<
 *         device, type)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlBrandType_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBrand)(__pyx_v_device, __pyx_v_type);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4213
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetBrand(nvmlDevice_t device, nvmlBrandType_t* type) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetBrand
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetBrand", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4223
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetIndex(nvmlDevice_t device, unsigned int* index) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetIndex
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetIndex(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_index) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetIndex", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4225
 * cdef nvmlReturn_t _nvmlDeviceGetIndex(nvmlDevice_t device, unsigned int* index) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetIndex
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetIndex == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4225, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4226
 *     global __nvmlDeviceGetIndex
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetIndex == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetIndex is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetIndex == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4227
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetIndex == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetIndex is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetIndex)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4228
 *     if __nvmlDeviceGetIndex == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetIndex is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetIndex)(
 *         device, index)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4228, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetIndex_is_n};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4228, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4228, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4227
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetIndex == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetIndex is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetIndex)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4226
 *     global __nvmlDeviceGetIndex
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetIndex == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetIndex is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4229
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetIndex is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetIndex)(             # <<<<<<<<<<<<<<
 *         device, index)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetIndex)(__pyx_v_device, __pyx_v_index);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4223
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetIndex(nvmlDevice_t device, unsigned int* index) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetIndex
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetIndex", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4233
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetSerial(nvmlDevice_t device, char* serial, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetSerial
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetSerial(nvmlDevice_t __pyx_v_device, char *__pyx_v_serial, unsigned int __pyx_v_length) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetSerial", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4235
 * cdef nvmlReturn_t _nvmlDeviceGetSerial(nvmlDevice_t device, char* serial, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetSerial
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetSerial == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4235, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4236
 *     global __nvmlDeviceGetSerial
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSerial == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSerial is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSerial == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4237
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSerial == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetSerial is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetSerial)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4238
 *     if __nvmlDeviceGetSerial == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSerial is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetSerial)(
 *         device, serial, length)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4238, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetSerial_is};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4238, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4238, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4237
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSerial == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetSerial is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetSerial)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4236
 *     global __nvmlDeviceGetSerial
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSerial == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSerial is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4239
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSerial is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetSerial)(             # <<<<<<<<<<<<<<
 *         device, serial, length)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, char *, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSerial)(__pyx_v_device, __pyx_v_serial, __pyx_v_length);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4233
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetSerial(nvmlDevice_t device, char* serial, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetSerial
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetSerial", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4243
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetModuleId(nvmlDevice_t device, unsigned int* moduleId) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetModuleId
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetModuleId(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_moduleId) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetModuleId", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4245
 * cdef nvmlReturn_t _nvmlDeviceGetModuleId(nvmlDevice_t device, unsigned int* moduleId) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetModuleId
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetModuleId == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4245, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4246
 *     global __nvmlDeviceGetModuleId
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetModuleId == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetModuleId is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetModuleId == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4247
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetModuleId == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetModuleId is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetModuleId)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4248
 *     if __nvmlDeviceGetModuleId == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetModuleId is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetModuleId)(
 *         device, moduleId)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4248, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetModuleId_i};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4248, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4248, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4247
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetModuleId == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetModuleId is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetModuleId)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4246
 *     global __nvmlDeviceGetModuleId
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetModuleId == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetModuleId is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4249
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetModuleId is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetModuleId)(             # <<<<<<<<<<<<<<
 *         device, moduleId)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetModuleId)(__pyx_v_device, __pyx_v_moduleId);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4243
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetModuleId(nvmlDevice_t device, unsigned int* moduleId) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetModuleId
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetModuleId", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4253
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetC2cModeInfoV(nvmlDevice_t device, nvmlC2cModeInfo_v1_t* c2cModeInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetC2cModeInfoV
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetC2cModeInfoV(nvmlDevice_t __pyx_v_device, nvmlC2cModeInfo_v1_t *__pyx_v_c2cModeInfo) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetC2cModeInfoV", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4255
 * cdef nvmlReturn_t _nvmlDeviceGetC2cModeInfoV(nvmlDevice_t device, nvmlC2cModeInfo_v1_t* c2cModeInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetC2cModeInfoV
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetC2cModeInfoV == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4255, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4256
 *     global __nvmlDeviceGetC2cModeInfoV
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetC2cModeInfoV == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetC2cModeInfoV is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetC2cModeInfoV == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4257
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetC2cModeInfoV == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetC2cModeInfoV is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlC2cModeInfo_v1_t*) noexcept nogil>__nvmlDeviceGetC2cModeInfoV)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4258
 *     if __nvmlDeviceGetC2cModeInfoV == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetC2cModeInfoV is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlC2cModeInfo_v1_t*) noexcept nogil>__nvmlDeviceGetC2cModeInfoV)(
 *         device, c2cModeInfo)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4258, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetC2cModeInf};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4258, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4258, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4257
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetC2cModeInfoV == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetC2cModeInfoV is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlC2cModeInfo_v1_t*) noexcept nogil>__nvmlDeviceGetC2cModeInfoV)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4256
 *     global __nvmlDeviceGetC2cModeInfoV
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetC2cModeInfoV == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetC2cModeInfoV is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4259
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetC2cModeInfoV is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlC2cModeInfo_v1_t*) noexcept nogil>__nvmlDeviceGetC2cModeInfoV)(             # <<<<<<<<<<<<<<
 *         device, c2cModeInfo)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlC2cModeInfo_v1_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetC2cModeInfoV)(__pyx_v_device, __pyx_v_c2cModeInfo);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4253
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetC2cModeInfoV(nvmlDevice_t device, nvmlC2cModeInfo_v1_t* c2cModeInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetC2cModeInfoV
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetC2cModeInfoV", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4263
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMemoryAffinity(nvmlDevice_t device, unsigned int nodeSetSize, unsigned long* nodeSet, nvmlAffinityScope_t scope) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMemoryAffinity
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMemoryAffinity(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_nodeSetSize, unsigned long *__pyx_v_nodeSet, nvmlAffinityScope_t __pyx_v_scope) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetMemoryAffinity", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4265
 * cdef nvmlReturn_t _nvmlDeviceGetMemoryAffinity(nvmlDevice_t device, unsigned int nodeSetSize, unsigned long* nodeSet, nvmlAffinityScope_t scope) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetMemoryAffinity
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetMemoryAffinity == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4265, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4266
 *     global __nvmlDeviceGetMemoryAffinity
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMemoryAffinity == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemoryAffinity is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryAffinity == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4267
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMemoryAffinity == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemoryAffinity is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned long*, nvmlAffinityScope_t) noexcept nogil>__nvmlDeviceGetMemoryAffinity)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4268
 *     if __nvmlDeviceGetMemoryAffinity == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemoryAffinity is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned long*, nvmlAffinityScope_t) noexcept nogil>__nvmlDeviceGetMemoryAffinity)(
 *         device, nodeSetSize, nodeSet, scope)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4268, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetMemoryAffi};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4268, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4268, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4267
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMemoryAffinity == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemoryAffinity is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned long*, nvmlAffinityScope_t) noexcept nogil>__nvmlDeviceGetMemoryAffinity)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4266
 *     global __nvmlDeviceGetMemoryAffinity
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMemoryAffinity == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemoryAffinity is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4269
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemoryAffinity is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned long*, nvmlAffinityScope_t) noexcept nogil>__nvmlDeviceGetMemoryAffinity)(             # <<<<<<<<<<<<<<
 *         device, nodeSetSize, nodeSet, scope)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned long *, nvmlAffinityScope_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryAffinity)(__pyx_v_device, __pyx_v_nodeSetSize, __pyx_v_nodeSet, __pyx_v_scope);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4263
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMemoryAffinity(nvmlDevice_t device, unsigned int nodeSetSize, unsigned long* nodeSet, nvmlAffinityScope_t scope) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMemoryAffinity
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetMemoryAffinity", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4273
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetCpuAffinityWithinScope(nvmlDevice_t device, unsigned int cpuSetSize, unsigned long* cpuSet, nvmlAffinityScope_t scope) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetCpuAffinityWithinScope
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetCpuAffinityWithinScope(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_cpuSetSize, unsigned long *__pyx_v_cpuSet, nvmlAffinityScope_t __pyx_v_scope) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetCpuAffinityWithinScope", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4275
 * cdef nvmlReturn_t _nvmlDeviceGetCpuAffinityWithinScope(nvmlDevice_t device, unsigned int cpuSetSize, unsigned long* cpuSet, nvmlAffinityScope_t scope) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetCpuAffinityWithinScope
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetCpuAffinityWithinScope == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4275, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4276
 *     global __nvmlDeviceGetCpuAffinityWithinScope
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCpuAffinityWithinScope == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCpuAffinityWithinScope is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCpuAffinityWithinScope == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4277
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCpuAffinityWithinScope == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetCpuAffinityWithinScope is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned long*, nvmlAffinityScope_t) noexcept nogil>__nvmlDeviceGetCpuAffinityWithinScope)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4278
 *     if __nvmlDeviceGetCpuAffinityWithinScope == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCpuAffinityWithinScope is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned long*, nvmlAffinityScope_t) noexcept nogil>__nvmlDeviceGetCpuAffinityWithinScope)(
 *         device, cpuSetSize, cpuSet, scope)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4278, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetCpuAffinit};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4278, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4278, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4277
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCpuAffinityWithinScope == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetCpuAffinityWithinScope is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned long*, nvmlAffinityScope_t) noexcept nogil>__nvmlDeviceGetCpuAffinityWithinScope)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4276
 *     global __nvmlDeviceGetCpuAffinityWithinScope
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCpuAffinityWithinScope == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCpuAffinityWithinScope is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4279
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCpuAffinityWithinScope is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned long*, nvmlAffinityScope_t) noexcept nogil>__nvmlDeviceGetCpuAffinityWithinScope)(             # <<<<<<<<<<<<<<
 *         device, cpuSetSize, cpuSet, scope)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned long *, nvmlAffinityScope_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCpuAffinityWithinScope)(__pyx_v_device, __pyx_v_cpuSetSize, __pyx_v_cpuSet, __pyx_v_scope);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4273
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetCpuAffinityWithinScope(nvmlDevice_t device, unsigned int cpuSetSize, unsigned long* cpuSet, nvmlAffinityScope_t scope) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetCpuAffinityWithinScope
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetCpuAffinityWithinScope", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4283
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetCpuAffinity(nvmlDevice_t device, unsigned int cpuSetSize, unsigned long* cpuSet) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetCpuAffinity
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetCpuAffinity(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_cpuSetSize, unsigned long *__pyx_v_cpuSet) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetCpuAffinity", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4285
 * cdef nvmlReturn_t _nvmlDeviceGetCpuAffinity(nvmlDevice_t device, unsigned int cpuSetSize, unsigned long* cpuSet) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetCpuAffinity
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetCpuAffinity == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4285, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4286
 *     global __nvmlDeviceGetCpuAffinity
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCpuAffinity == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCpuAffinity is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCpuAffinity == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4287
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCpuAffinity == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetCpuAffinity is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned long*) noexcept nogil>__nvmlDeviceGetCpuAffinity)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4288
 *     if __nvmlDeviceGetCpuAffinity == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCpuAffinity is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned long*) noexcept nogil>__nvmlDeviceGetCpuAffinity)(
 *         device, cpuSetSize, cpuSet)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4288, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetCpuAffinit_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4288, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4288, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4287
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCpuAffinity == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetCpuAffinity is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned long*) noexcept nogil>__nvmlDeviceGetCpuAffinity)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4286
 *     global __nvmlDeviceGetCpuAffinity
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCpuAffinity == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCpuAffinity is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4289
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCpuAffinity is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned long*) noexcept nogil>__nvmlDeviceGetCpuAffinity)(             # <<<<<<<<<<<<<<
 *         device, cpuSetSize, cpuSet)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned long *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCpuAffinity)(__pyx_v_device, __pyx_v_cpuSetSize, __pyx_v_cpuSet);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4283
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetCpuAffinity(nvmlDevice_t device, unsigned int cpuSetSize, unsigned long* cpuSet) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetCpuAffinity
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetCpuAffinity", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4293
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetCpuAffinity(nvmlDevice_t device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetCpuAffinity
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetCpuAffinity(nvmlDevice_t __pyx_v_device) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetCpuAffinity", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4295
 * cdef nvmlReturn_t _nvmlDeviceSetCpuAffinity(nvmlDevice_t device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetCpuAffinity
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetCpuAffinity == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4295, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4296
 *     global __nvmlDeviceSetCpuAffinity
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetCpuAffinity == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetCpuAffinity is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetCpuAffinity == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4297
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetCpuAffinity == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetCpuAffinity is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t) noexcept nogil>__nvmlDeviceSetCpuAffinity)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4298
 *     if __nvmlDeviceSetCpuAffinity == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetCpuAffinity is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t) noexcept nogil>__nvmlDeviceSetCpuAffinity)(
 *         device)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4298, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetCpuAffinit};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4298, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4298, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4297
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetCpuAffinity == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetCpuAffinity is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t) noexcept nogil>__nvmlDeviceSetCpuAffinity)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4296
 *     global __nvmlDeviceSetCpuAffinity
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetCpuAffinity == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetCpuAffinity is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4299
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetCpuAffinity is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t) noexcept nogil>__nvmlDeviceSetCpuAffinity)(             # <<<<<<<<<<<<<<
 *         device)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetCpuAffinity)(__pyx_v_device);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4293
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetCpuAffinity(nvmlDevice_t device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetCpuAffinity
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetCpuAffinity", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4303
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceClearCpuAffinity(nvmlDevice_t device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceClearCpuAffinity
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceClearCpuAffinity(nvmlDevice_t __pyx_v_device) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceClearCpuAffinity", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4305
 * cdef nvmlReturn_t _nvmlDeviceClearCpuAffinity(nvmlDevice_t device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceClearCpuAffinity
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceClearCpuAffinity == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4305, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4306
 *     global __nvmlDeviceClearCpuAffinity
 *     _check_or_init_nvml()
 *     if __nvmlDeviceClearCpuAffinity == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceClearCpuAffinity is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearCpuAffinity == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4307
 *     _check_or_init_nvml()
 *     if __nvmlDeviceClearCpuAffinity == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceClearCpuAffinity is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t) noexcept nogil>__nvmlDeviceClearCpuAffinity)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4308
 *     if __nvmlDeviceClearCpuAffinity == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceClearCpuAffinity is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t) noexcept nogil>__nvmlDeviceClearCpuAffinity)(
 *         device)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4308, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceClearCpuAffin};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4308, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4308, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4307
 *     _check_or_init_nvml()
 *     if __nvmlDeviceClearCpuAffinity == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceClearCpuAffinity is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t) noexcept nogil>__nvmlDeviceClearCpuAffinity)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4306
 *     global __nvmlDeviceClearCpuAffinity
 *     _check_or_init_nvml()
 *     if __nvmlDeviceClearCpuAffinity == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceClearCpuAffinity is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4309
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceClearCpuAffinity is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t) noexcept nogil>__nvmlDeviceClearCpuAffinity)(             # <<<<<<<<<<<<<<
 *         device)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearCpuAffinity)(__pyx_v_device);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4303
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceClearCpuAffinity(nvmlDevice_t device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceClearCpuAffinity
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceClearCpuAffinity", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4313
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetNumaNodeId(nvmlDevice_t device, unsigned int* node) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetNumaNodeId
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetNumaNodeId(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_node) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetNumaNodeId", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4315
 * cdef nvmlReturn_t _nvmlDeviceGetNumaNodeId(nvmlDevice_t device, unsigned int* node) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetNumaNodeId
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetNumaNodeId == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4315, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4316
 *     global __nvmlDeviceGetNumaNodeId
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNumaNodeId == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNumaNodeId is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNumaNodeId == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4317
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNumaNodeId == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetNumaNodeId is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetNumaNodeId)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4318
 *     if __nvmlDeviceGetNumaNodeId == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNumaNodeId is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetNumaNodeId)(
 *         device, node)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4318, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetNumaNodeId};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4318, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4318, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4317
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNumaNodeId == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetNumaNodeId is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetNumaNodeId)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4316
 *     global __nvmlDeviceGetNumaNodeId
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNumaNodeId == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNumaNodeId is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4319
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNumaNodeId is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetNumaNodeId)(             # <<<<<<<<<<<<<<
 *         device, node)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNumaNodeId)(__pyx_v_device, __pyx_v_node);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4313
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetNumaNodeId(nvmlDevice_t device, unsigned int* node) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetNumaNodeId
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetNumaNodeId", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4323
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetTopologyCommonAncestor(nvmlDevice_t device1, nvmlDevice_t device2, nvmlGpuTopologyLevel_t* pathInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetTopologyCommonAncestor
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetTopologyCommonAncestor(nvmlDevice_t __pyx_v_device1, nvmlDevice_t __pyx_v_device2, nvmlGpuTopologyLevel_t *__pyx_v_pathInfo) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetTopologyCommonAncestor", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4325
 * cdef nvmlReturn_t _nvmlDeviceGetTopologyCommonAncestor(nvmlDevice_t device1, nvmlDevice_t device2, nvmlGpuTopologyLevel_t* pathInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetTopologyCommonAncestor
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetTopologyCommonAncestor == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4325, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4326
 *     global __nvmlDeviceGetTopologyCommonAncestor
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTopologyCommonAncestor == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTopologyCommonAncestor is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTopologyCommonAncestor == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4327
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTopologyCommonAncestor == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetTopologyCommonAncestor is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevice_t, nvmlGpuTopologyLevel_t*) noexcept nogil>__nvmlDeviceGetTopologyCommonAncestor)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4328
 *     if __nvmlDeviceGetTopologyCommonAncestor == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTopologyCommonAncestor is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevice_t, nvmlGpuTopologyLevel_t*) noexcept nogil>__nvmlDeviceGetTopologyCommonAncestor)(
 *         device1, device2, pathInfo)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4328, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetTopologyCo};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4328, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4328, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4327
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTopologyCommonAncestor == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetTopologyCommonAncestor is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevice_t, nvmlGpuTopologyLevel_t*) noexcept nogil>__nvmlDeviceGetTopologyCommonAncestor)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4326
 *     global __nvmlDeviceGetTopologyCommonAncestor
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTopologyCommonAncestor == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTopologyCommonAncestor is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4329
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTopologyCommonAncestor is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevice_t, nvmlGpuTopologyLevel_t*) noexcept nogil>__nvmlDeviceGetTopologyCommonAncestor)(             # <<<<<<<<<<<<<<
 *         device1, device2, pathInfo)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlDevice_t, nvmlGpuTopologyLevel_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTopologyCommonAncestor)(__pyx_v_device1, __pyx_v_device2, __pyx_v_pathInfo);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4323
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetTopologyCommonAncestor(nvmlDevice_t device1, nvmlDevice_t device2, nvmlGpuTopologyLevel_t* pathInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetTopologyCommonAncestor
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetTopologyCommonAncestor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4333
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetTopologyNearestGpus(nvmlDevice_t device, nvmlGpuTopologyLevel_t level, unsigned int* count, nvmlDevice_t* deviceArray) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetTopologyNearestGpus
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetTopologyNearestGpus(nvmlDevice_t __pyx_v_device, nvmlGpuTopologyLevel_t __pyx_v_level, unsigned int *__pyx_v_count, nvmlDevice_t *__pyx_v_deviceArray) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetTopologyNearestGpus", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4335
 * cdef nvmlReturn_t _nvmlDeviceGetTopologyNearestGpus(nvmlDevice_t device, nvmlGpuTopologyLevel_t level, unsigned int* count, nvmlDevice_t* deviceArray) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetTopologyNearestGpus
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetTopologyNearestGpus == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4335, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4336
 *     global __nvmlDeviceGetTopologyNearestGpus
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTopologyNearestGpus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTopologyNearestGpus is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTopologyNearestGpus == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4337
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTopologyNearestGpus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetTopologyNearestGpus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuTopologyLevel_t, unsigned int*, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetTopologyNearestGpus)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4338
 *     if __nvmlDeviceGetTopologyNearestGpus == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTopologyNearestGpus is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuTopologyLevel_t, unsigned int*, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetTopologyNearestGpus)(
 *         device, level, count, deviceArray)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4338, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetTopologyNe};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4338, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4338, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4337
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTopologyNearestGpus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetTopologyNearestGpus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuTopologyLevel_t, unsigned int*, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetTopologyNearestGpus)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4336
 *     global __nvmlDeviceGetTopologyNearestGpus
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTopologyNearestGpus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTopologyNearestGpus is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4339
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTopologyNearestGpus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuTopologyLevel_t, unsigned int*, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetTopologyNearestGpus)(             # <<<<<<<<<<<<<<
 *         device, level, count, deviceArray)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuTopologyLevel_t, unsigned int *, nvmlDevice_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTopologyNearestGpus)(__pyx_v_device, __pyx_v_level, __pyx_v_count, __pyx_v_deviceArray);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4333
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetTopologyNearestGpus(nvmlDevice_t device, nvmlGpuTopologyLevel_t level, unsigned int* count, nvmlDevice_t* deviceArray) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetTopologyNearestGpus
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetTopologyNearestGpus", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4343
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetP2PStatus(nvmlDevice_t device1, nvmlDevice_t device2, nvmlGpuP2PCapsIndex_t p2pIndex, nvmlGpuP2PStatus_t* p2pStatus) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetP2PStatus
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetP2PStatus(nvmlDevice_t __pyx_v_device1, nvmlDevice_t __pyx_v_device2, nvmlGpuP2PCapsIndex_t __pyx_v_p2pIndex, nvmlGpuP2PStatus_t *__pyx_v_p2pStatus) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetP2PStatus", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4345
 * cdef nvmlReturn_t _nvmlDeviceGetP2PStatus(nvmlDevice_t device1, nvmlDevice_t device2, nvmlGpuP2PCapsIndex_t p2pIndex, nvmlGpuP2PStatus_t* p2pStatus) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetP2PStatus
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetP2PStatus == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4345, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4346
 *     global __nvmlDeviceGetP2PStatus
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetP2PStatus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetP2PStatus is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetP2PStatus == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4347
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetP2PStatus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetP2PStatus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevice_t, nvmlGpuP2PCapsIndex_t, nvmlGpuP2PStatus_t*) noexcept nogil>__nvmlDeviceGetP2PStatus)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4348
 *     if __nvmlDeviceGetP2PStatus == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetP2PStatus is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevice_t, nvmlGpuP2PCapsIndex_t, nvmlGpuP2PStatus_t*) noexcept nogil>__nvmlDeviceGetP2PStatus)(
 *         device1, device2, p2pIndex, p2pStatus)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4348, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetP2PStatus};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4348, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4348, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4347
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetP2PStatus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetP2PStatus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevice_t, nvmlGpuP2PCapsIndex_t, nvmlGpuP2PStatus_t*) noexcept nogil>__nvmlDeviceGetP2PStatus)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4346
 *     global __nvmlDeviceGetP2PStatus
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetP2PStatus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetP2PStatus is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4349
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetP2PStatus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevice_t, nvmlGpuP2PCapsIndex_t, nvmlGpuP2PStatus_t*) noexcept nogil>__nvmlDeviceGetP2PStatus)(             # <<<<<<<<<<<<<<
 *         device1, device2, p2pIndex, p2pStatus)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlDevice_t, nvmlGpuP2PCapsIndex_t, nvmlGpuP2PStatus_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetP2PStatus)(__pyx_v_device1, __pyx_v_device2, __pyx_v_p2pIndex, __pyx_v_p2pStatus);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4343
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetP2PStatus(nvmlDevice_t device1, nvmlDevice_t device2, nvmlGpuP2PCapsIndex_t p2pIndex, nvmlGpuP2PStatus_t* p2pStatus) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetP2PStatus
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetP2PStatus", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4353
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetUUID(nvmlDevice_t device, char* uuid, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetUUID
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetUUID(nvmlDevice_t __pyx_v_device, char *__pyx_v_uuid, unsigned int __pyx_v_length) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetUUID", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4355
 * cdef nvmlReturn_t _nvmlDeviceGetUUID(nvmlDevice_t device, char* uuid, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetUUID
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetUUID == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4355, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4356
 *     global __nvmlDeviceGetUUID
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetUUID == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetUUID is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetUUID == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4357
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetUUID == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetUUID is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetUUID)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4358
 *     if __nvmlDeviceGetUUID == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetUUID is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetUUID)(
 *         device, uuid, length)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4358, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetUUID_is_no};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4358, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4358, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4357
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetUUID == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetUUID is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetUUID)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4356
 *     global __nvmlDeviceGetUUID
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetUUID == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetUUID is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4359
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetUUID is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetUUID)(             # <<<<<<<<<<<<<<
 *         device, uuid, length)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, char *, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetUUID)(__pyx_v_device, __pyx_v_uuid, __pyx_v_length);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4353
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetUUID(nvmlDevice_t device, char* uuid, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetUUID
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetUUID", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4363
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMinorNumber(nvmlDevice_t device, unsigned int* minorNumber) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMinorNumber
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMinorNumber(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_minorNumber) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetMinorNumber", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4365
 * cdef nvmlReturn_t _nvmlDeviceGetMinorNumber(nvmlDevice_t device, unsigned int* minorNumber) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetMinorNumber
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetMinorNumber == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4365, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4366
 *     global __nvmlDeviceGetMinorNumber
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMinorNumber == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMinorNumber is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMinorNumber == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4367
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMinorNumber == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMinorNumber is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMinorNumber)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4368
 *     if __nvmlDeviceGetMinorNumber == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMinorNumber is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMinorNumber)(
 *         device, minorNumber)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4368, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetMinorNumbe};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4368, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4368, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4367
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMinorNumber == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMinorNumber is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMinorNumber)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4366
 *     global __nvmlDeviceGetMinorNumber
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMinorNumber == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMinorNumber is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4369
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMinorNumber is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMinorNumber)(             # <<<<<<<<<<<<<<
 *         device, minorNumber)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMinorNumber)(__pyx_v_device, __pyx_v_minorNumber);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4363
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMinorNumber(nvmlDevice_t device, unsigned int* minorNumber) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMinorNumber
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetMinorNumber", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4373
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetBoardPartNumber(nvmlDevice_t device, char* partNumber, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetBoardPartNumber
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetBoardPartNumber(nvmlDevice_t __pyx_v_device, char *__pyx_v_partNumber, unsigned int __pyx_v_length) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetBoardPartNumber", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4375
 * cdef nvmlReturn_t _nvmlDeviceGetBoardPartNumber(nvmlDevice_t device, char* partNumber, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetBoardPartNumber
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetBoardPartNumber == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4375, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4376
 *     global __nvmlDeviceGetBoardPartNumber
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetBoardPartNumber == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetBoardPartNumber is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBoardPartNumber == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4377
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetBoardPartNumber == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetBoardPartNumber is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetBoardPartNumber)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4378
 *     if __nvmlDeviceGetBoardPartNumber == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetBoardPartNumber is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetBoardPartNumber)(
 *         device, partNumber, length)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4378, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetBoardPartN};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4378, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4378, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4377
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetBoardPartNumber == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetBoardPartNumber is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetBoardPartNumber)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4376
 *     global __nvmlDeviceGetBoardPartNumber
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetBoardPartNumber == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetBoardPartNumber is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4379
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetBoardPartNumber is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetBoardPartNumber)(             # <<<<<<<<<<<<<<
 *         device, partNumber, length)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, char *, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBoardPartNumber)(__pyx_v_device, __pyx_v_partNumber, __pyx_v_length);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4373
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetBoardPartNumber(nvmlDevice_t device, char* partNumber, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetBoardPartNumber
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetBoardPartNumber", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4383
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetInforomVersion(nvmlDevice_t device, nvmlInforomObject_t object, char* version, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetInforomVersion
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetInforomVersion(nvmlDevice_t __pyx_v_device, nvmlInforomObject_t __pyx_v_object, char *__pyx_v_version, unsigned int __pyx_v_length) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetInforomVersion", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4385
 * cdef nvmlReturn_t _nvmlDeviceGetInforomVersion(nvmlDevice_t device, nvmlInforomObject_t object, char* version, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetInforomVersion
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetInforomVersion == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4385, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4386
 *     global __nvmlDeviceGetInforomVersion
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetInforomVersion == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetInforomVersion is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetInforomVersion == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4387
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetInforomVersion == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetInforomVersion is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlInforomObject_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetInforomVersion)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4388
 *     if __nvmlDeviceGetInforomVersion == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetInforomVersion is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlInforomObject_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetInforomVersion)(
 *         device, object, version, length)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4388, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetInforomVer};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4388, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4388, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4387
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetInforomVersion == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetInforomVersion is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlInforomObject_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetInforomVersion)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4386
 *     global __nvmlDeviceGetInforomVersion
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetInforomVersion == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetInforomVersion is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4389
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetInforomVersion is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlInforomObject_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetInforomVersion)(             # <<<<<<<<<<<<<<
 *         device, object, version, length)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlInforomObject_t, char *, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetInforomVersion)(__pyx_v_device, __pyx_v_object, __pyx_v_version, __pyx_v_length);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4383
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetInforomVersion(nvmlDevice_t device, nvmlInforomObject_t object, char* version, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetInforomVersion
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetInforomVersion", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4393
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetInforomImageVersion(nvmlDevice_t device, char* version, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetInforomImageVersion
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetInforomImageVersion(nvmlDevice_t __pyx_v_device, char *__pyx_v_version, unsigned int __pyx_v_length) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetInforomImageVersion", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4395
 * cdef nvmlReturn_t _nvmlDeviceGetInforomImageVersion(nvmlDevice_t device, char* version, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetInforomImageVersion
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetInforomImageVersion == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4395, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4396
 *     global __nvmlDeviceGetInforomImageVersion
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetInforomImageVersion == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetInforomImageVersion is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetInforomImageVersion == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4397
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetInforomImageVersion == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetInforomImageVersion is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetInforomImageVersion)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4398
 *     if __nvmlDeviceGetInforomImageVersion == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetInforomImageVersion is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetInforomImageVersion)(
 *         device, version, length)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4398, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetInforomIma};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4398, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4398, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4397
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetInforomImageVersion == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetInforomImageVersion is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetInforomImageVersion)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4396
 *     global __nvmlDeviceGetInforomImageVersion
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetInforomImageVersion == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetInforomImageVersion is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4399
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetInforomImageVersion is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetInforomImageVersion)(             # <<<<<<<<<<<<<<
 *         device, version, length)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, char *, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetInforomImageVersion)(__pyx_v_device, __pyx_v_version, __pyx_v_length);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4393
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetInforomImageVersion(nvmlDevice_t device, char* version, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetInforomImageVersion
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetInforomImageVersion", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4403
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetInforomConfigurationChecksum(nvmlDevice_t device, unsigned int* checksum) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetInforomConfigurationChecksum
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetInforomConfigurationChecksum(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_checksum) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetInforomConfigurationChecksum", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4405
 * cdef nvmlReturn_t _nvmlDeviceGetInforomConfigurationChecksum(nvmlDevice_t device, unsigned int* checksum) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetInforomConfigurationChecksum
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetInforomConfigurationChecksum == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4405, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4406
 *     global __nvmlDeviceGetInforomConfigurationChecksum
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetInforomConfigurationChecksum == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetInforomConfigurationChecksum is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetInforomConfigurationChecksum == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4407
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetInforomConfigurationChecksum == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetInforomConfigurationChecksum is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetInforomConfigurationChecksum)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4408
 *     if __nvmlDeviceGetInforomConfigurationChecksum == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetInforomConfigurationChecksum is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetInforomConfigurationChecksum)(
 *         device, checksum)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4408, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetInforomCon};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4408, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4408, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4407
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetInforomConfigurationChecksum == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetInforomConfigurationChecksum is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetInforomConfigurationChecksum)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4406
 *     global __nvmlDeviceGetInforomConfigurationChecksum
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetInforomConfigurationChecksum == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetInforomConfigurationChecksum is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4409
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetInforomConfigurationChecksum is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetInforomConfigurationChecksum)(             # <<<<<<<<<<<<<<
 *         device, checksum)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetInforomConfigurationChecksum)(__pyx_v_device, __pyx_v_checksum);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4403
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetInforomConfigurationChecksum(nvmlDevice_t device, unsigned int* checksum) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetInforomConfigurationChecksum
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetInforomConfigurationChecksum", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4413
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceValidateInforom(nvmlDevice_t device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceValidateInforom
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceValidateInforom(nvmlDevice_t __pyx_v_device) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceValidateInforom", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4415
 * cdef nvmlReturn_t _nvmlDeviceValidateInforom(nvmlDevice_t device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceValidateInforom
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceValidateInforom == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4415, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4416
 *     global __nvmlDeviceValidateInforom
 *     _check_or_init_nvml()
 *     if __nvmlDeviceValidateInforom == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceValidateInforom is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceValidateInforom == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4417
 *     _check_or_init_nvml()
 *     if __nvmlDeviceValidateInforom == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceValidateInforom is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t) noexcept nogil>__nvmlDeviceValidateInforom)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4418
 *     if __nvmlDeviceValidateInforom == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceValidateInforom is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t) noexcept nogil>__nvmlDeviceValidateInforom)(
 *         device)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4418, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceValidateInfor};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4418, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4418, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4417
 *     _check_or_init_nvml()
 *     if __nvmlDeviceValidateInforom == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceValidateInforom is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t) noexcept nogil>__nvmlDeviceValidateInforom)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4416
 *     global __nvmlDeviceValidateInforom
 *     _check_or_init_nvml()
 *     if __nvmlDeviceValidateInforom == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceValidateInforom is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4419
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceValidateInforom is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t) noexcept nogil>__nvmlDeviceValidateInforom)(             # <<<<<<<<<<<<<<
 *         device)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceValidateInforom)(__pyx_v_device);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4413
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceValidateInforom(nvmlDevice_t device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceValidateInforom
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceValidateInforom", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4423
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetLastBBXFlushTime(nvmlDevice_t device, unsigned long long* timestamp, unsigned long* durationUs) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetLastBBXFlushTime
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetLastBBXFlushTime(nvmlDevice_t __pyx_v_device, unsigned PY_LONG_LONG *__pyx_v_timestamp, unsigned long *__pyx_v_durationUs) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetLastBBXFlushTime", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4425
 * cdef nvmlReturn_t _nvmlDeviceGetLastBBXFlushTime(nvmlDevice_t device, unsigned long long* timestamp, unsigned long* durationUs) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetLastBBXFlushTime
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetLastBBXFlushTime == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4425, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4426
 *     global __nvmlDeviceGetLastBBXFlushTime
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetLastBBXFlushTime == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetLastBBXFlushTime is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetLastBBXFlushTime == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4427
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetLastBBXFlushTime == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetLastBBXFlushTime is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long*, unsigned long*) noexcept nogil>__nvmlDeviceGetLastBBXFlushTime)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4428
 *     if __nvmlDeviceGetLastBBXFlushTime == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetLastBBXFlushTime is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long*, unsigned long*) noexcept nogil>__nvmlDeviceGetLastBBXFlushTime)(
 *         device, timestamp, durationUs)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4428, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetLastBBXFlu};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4428, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4428, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4427
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetLastBBXFlushTime == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetLastBBXFlushTime is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long*, unsigned long*) noexcept nogil>__nvmlDeviceGetLastBBXFlushTime)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4426
 *     global __nvmlDeviceGetLastBBXFlushTime
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetLastBBXFlushTime == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetLastBBXFlushTime is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4429
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetLastBBXFlushTime is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long*, unsigned long*) noexcept nogil>__nvmlDeviceGetLastBBXFlushTime)(             # <<<<<<<<<<<<<<
 *         device, timestamp, durationUs)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned PY_LONG_LONG *, unsigned long *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetLastBBXFlushTime)(__pyx_v_device, __pyx_v_timestamp, __pyx_v_durationUs);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4423
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetLastBBXFlushTime(nvmlDevice_t device, unsigned long long* timestamp, unsigned long* durationUs) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetLastBBXFlushTime
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetLastBBXFlushTime", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4433
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetDisplayMode(nvmlDevice_t device, nvmlEnableState_t* display) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetDisplayMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetDisplayMode(nvmlDevice_t __pyx_v_device, nvmlEnableState_t *__pyx_v_display) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetDisplayMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4435
 * cdef nvmlReturn_t _nvmlDeviceGetDisplayMode(nvmlDevice_t device, nvmlEnableState_t* display) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetDisplayMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetDisplayMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4435, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4436
 *     global __nvmlDeviceGetDisplayMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDisplayMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDisplayMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDisplayMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4437
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDisplayMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetDisplayMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetDisplayMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4438
 *     if __nvmlDeviceGetDisplayMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDisplayMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetDisplayMode)(
 *         device, display)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4438, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetDisplayMod};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4438, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4438, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4437
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDisplayMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetDisplayMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetDisplayMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4436
 *     global __nvmlDeviceGetDisplayMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDisplayMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDisplayMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4439
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDisplayMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetDisplayMode)(             # <<<<<<<<<<<<<<
 *         device, display)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDisplayMode)(__pyx_v_device, __pyx_v_display);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4433
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetDisplayMode(nvmlDevice_t device, nvmlEnableState_t* display) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetDisplayMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetDisplayMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4443
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetDisplayActive(nvmlDevice_t device, nvmlEnableState_t* isActive) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetDisplayActive
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetDisplayActive(nvmlDevice_t __pyx_v_device, nvmlEnableState_t *__pyx_v_isActive) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetDisplayActive", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4445
 * cdef nvmlReturn_t _nvmlDeviceGetDisplayActive(nvmlDevice_t device, nvmlEnableState_t* isActive) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetDisplayActive
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetDisplayActive == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4445, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4446
 *     global __nvmlDeviceGetDisplayActive
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDisplayActive == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDisplayActive is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDisplayActive == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4447
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDisplayActive == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetDisplayActive is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetDisplayActive)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4448
 *     if __nvmlDeviceGetDisplayActive == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDisplayActive is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetDisplayActive)(
 *         device, isActive)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4448, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetDisplayAct};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4448, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4448, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4447
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDisplayActive == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetDisplayActive is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetDisplayActive)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4446
 *     global __nvmlDeviceGetDisplayActive
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDisplayActive == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDisplayActive is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4449
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDisplayActive is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetDisplayActive)(             # <<<<<<<<<<<<<<
 *         device, isActive)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDisplayActive)(__pyx_v_device, __pyx_v_isActive);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4443
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetDisplayActive(nvmlDevice_t device, nvmlEnableState_t* isActive) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetDisplayActive
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetDisplayActive", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4453
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPersistenceMode(nvmlDevice_t device, nvmlEnableState_t* mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPersistenceMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPersistenceMode(nvmlDevice_t __pyx_v_device, nvmlEnableState_t *__pyx_v_mode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetPersistenceMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4455
 * cdef nvmlReturn_t _nvmlDeviceGetPersistenceMode(nvmlDevice_t device, nvmlEnableState_t* mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetPersistenceMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetPersistenceMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4455, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4456
 *     global __nvmlDeviceGetPersistenceMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPersistenceMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPersistenceMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPersistenceMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4457
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPersistenceMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPersistenceMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetPersistenceMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4458
 *     if __nvmlDeviceGetPersistenceMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPersistenceMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetPersistenceMode)(
 *         device, mode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4458, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetPersistenc};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4458, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4458, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4457
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPersistenceMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPersistenceMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetPersistenceMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4456
 *     global __nvmlDeviceGetPersistenceMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPersistenceMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPersistenceMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4459
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPersistenceMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetPersistenceMode)(             # <<<<<<<<<<<<<<
 *         device, mode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPersistenceMode)(__pyx_v_device, __pyx_v_mode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4453
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPersistenceMode(nvmlDevice_t device, nvmlEnableState_t* mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPersistenceMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetPersistenceMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4463
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPciInfoExt(nvmlDevice_t device, nvmlPciInfoExt_t* pci) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPciInfoExt
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPciInfoExt(nvmlDevice_t __pyx_v_device, nvmlPciInfoExt_t *__pyx_v_pci) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetPciInfoExt", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4465
 * cdef nvmlReturn_t _nvmlDeviceGetPciInfoExt(nvmlDevice_t device, nvmlPciInfoExt_t* pci) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetPciInfoExt
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetPciInfoExt == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4465, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4466
 *     global __nvmlDeviceGetPciInfoExt
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPciInfoExt == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPciInfoExt is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPciInfoExt == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4467
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPciInfoExt == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPciInfoExt is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPciInfoExt_t*) noexcept nogil>__nvmlDeviceGetPciInfoExt)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4468
 *     if __nvmlDeviceGetPciInfoExt == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPciInfoExt is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPciInfoExt_t*) noexcept nogil>__nvmlDeviceGetPciInfoExt)(
 *         device, pci)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4468, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetPciInfoExt};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4468, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4468, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4467
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPciInfoExt == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPciInfoExt is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPciInfoExt_t*) noexcept nogil>__nvmlDeviceGetPciInfoExt)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4466
 *     global __nvmlDeviceGetPciInfoExt
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPciInfoExt == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPciInfoExt is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4469
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPciInfoExt is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPciInfoExt_t*) noexcept nogil>__nvmlDeviceGetPciInfoExt)(             # <<<<<<<<<<<<<<
 *         device, pci)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlPciInfoExt_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPciInfoExt)(__pyx_v_device, __pyx_v_pci);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4463
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPciInfoExt(nvmlDevice_t device, nvmlPciInfoExt_t* pci) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPciInfoExt
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetPciInfoExt", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4473
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPciInfo_v3(nvmlDevice_t device, nvmlPciInfo_t* pci) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPciInfo_v3
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPciInfo_v3(nvmlDevice_t __pyx_v_device, nvmlPciInfo_t *__pyx_v_pci) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetPciInfo_v3", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4475
 * cdef nvmlReturn_t _nvmlDeviceGetPciInfo_v3(nvmlDevice_t device, nvmlPciInfo_t* pci) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetPciInfo_v3
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetPciInfo_v3 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4475, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4476
 *     global __nvmlDeviceGetPciInfo_v3
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPciInfo_v3 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPciInfo_v3 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPciInfo_v3 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4477
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPciInfo_v3 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPciInfo_v3 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPciInfo_t*) noexcept nogil>__nvmlDeviceGetPciInfo_v3)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4478
 *     if __nvmlDeviceGetPciInfo_v3 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPciInfo_v3 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPciInfo_t*) noexcept nogil>__nvmlDeviceGetPciInfo_v3)(
 *         device, pci)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4478, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetPciInfo_v3};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4478, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4478, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4477
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPciInfo_v3 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPciInfo_v3 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPciInfo_t*) noexcept nogil>__nvmlDeviceGetPciInfo_v3)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4476
 *     global __nvmlDeviceGetPciInfo_v3
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPciInfo_v3 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPciInfo_v3 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4479
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPciInfo_v3 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPciInfo_t*) noexcept nogil>__nvmlDeviceGetPciInfo_v3)(             # <<<<<<<<<<<<<<
 *         device, pci)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlPciInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPciInfo_v3)(__pyx_v_device, __pyx_v_pci);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4473
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPciInfo_v3(nvmlDevice_t device, nvmlPciInfo_t* pci) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPciInfo_v3
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetPciInfo_v3", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4483
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMaxPcieLinkGeneration(nvmlDevice_t device, unsigned int* maxLinkGen) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMaxPcieLinkGeneration
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMaxPcieLinkGeneration(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_maxLinkGen) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetMaxPcieLinkGeneration", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4485
 * cdef nvmlReturn_t _nvmlDeviceGetMaxPcieLinkGeneration(nvmlDevice_t device, unsigned int* maxLinkGen) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetMaxPcieLinkGeneration
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetMaxPcieLinkGeneration == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4485, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4486
 *     global __nvmlDeviceGetMaxPcieLinkGeneration
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMaxPcieLinkGeneration == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxPcieLinkGeneration is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxPcieLinkGeneration == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4487
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMaxPcieLinkGeneration == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxPcieLinkGeneration is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMaxPcieLinkGeneration)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4488
 *     if __nvmlDeviceGetMaxPcieLinkGeneration == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxPcieLinkGeneration is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMaxPcieLinkGeneration)(
 *         device, maxLinkGen)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4488, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetMaxPcieLin};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4488, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4488, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4487
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMaxPcieLinkGeneration == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxPcieLinkGeneration is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMaxPcieLinkGeneration)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4486
 *     global __nvmlDeviceGetMaxPcieLinkGeneration
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMaxPcieLinkGeneration == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxPcieLinkGeneration is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4489
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxPcieLinkGeneration is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMaxPcieLinkGeneration)(             # <<<<<<<<<<<<<<
 *         device, maxLinkGen)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxPcieLinkGeneration)(__pyx_v_device, __pyx_v_maxLinkGen);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4483
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMaxPcieLinkGeneration(nvmlDevice_t device, unsigned int* maxLinkGen) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMaxPcieLinkGeneration
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetMaxPcieLinkGeneration", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4493
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGpuMaxPcieLinkGeneration(nvmlDevice_t device, unsigned int* maxLinkGenDevice) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGpuMaxPcieLinkGeneration
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGpuMaxPcieLinkGeneration(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_maxLinkGenDevice) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetGpuMaxPcieLinkGeneration", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4495
 * cdef nvmlReturn_t _nvmlDeviceGetGpuMaxPcieLinkGeneration(nvmlDevice_t device, unsigned int* maxLinkGenDevice) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetGpuMaxPcieLinkGeneration
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetGpuMaxPcieLinkGeneration == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4495, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4496
 *     global __nvmlDeviceGetGpuMaxPcieLinkGeneration
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuMaxPcieLinkGeneration == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuMaxPcieLinkGeneration is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuMaxPcieLinkGeneration == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4497
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuMaxPcieLinkGeneration == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuMaxPcieLinkGeneration is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetGpuMaxPcieLinkGeneration)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4498
 *     if __nvmlDeviceGetGpuMaxPcieLinkGeneration == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuMaxPcieLinkGeneration is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetGpuMaxPcieLinkGeneration)(
 *         device, maxLinkGenDevice)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4498, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetGpuMaxPcie};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4498, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4498, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4497
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuMaxPcieLinkGeneration == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuMaxPcieLinkGeneration is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetGpuMaxPcieLinkGeneration)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4496
 *     global __nvmlDeviceGetGpuMaxPcieLinkGeneration
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuMaxPcieLinkGeneration == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuMaxPcieLinkGeneration is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4499
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuMaxPcieLinkGeneration is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetGpuMaxPcieLinkGeneration)(             # <<<<<<<<<<<<<<
 *         device, maxLinkGenDevice)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuMaxPcieLinkGeneration)(__pyx_v_device, __pyx_v_maxLinkGenDevice);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4493
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGpuMaxPcieLinkGeneration(nvmlDevice_t device, unsigned int* maxLinkGenDevice) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGpuMaxPcieLinkGeneration
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetGpuMaxPcieLinkGeneration", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4503
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMaxPcieLinkWidth(nvmlDevice_t device, unsigned int* maxLinkWidth) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMaxPcieLinkWidth
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMaxPcieLinkWidth(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_maxLinkWidth) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetMaxPcieLinkWidth", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4505
 * cdef nvmlReturn_t _nvmlDeviceGetMaxPcieLinkWidth(nvmlDevice_t device, unsigned int* maxLinkWidth) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetMaxPcieLinkWidth
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetMaxPcieLinkWidth == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4505, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4506
 *     global __nvmlDeviceGetMaxPcieLinkWidth
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMaxPcieLinkWidth == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxPcieLinkWidth is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxPcieLinkWidth == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4507
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMaxPcieLinkWidth == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxPcieLinkWidth is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMaxPcieLinkWidth)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4508
 *     if __nvmlDeviceGetMaxPcieLinkWidth == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxPcieLinkWidth is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMaxPcieLinkWidth)(
 *         device, maxLinkWidth)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4508, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetMaxPcieLin_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4508, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4508, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4507
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMaxPcieLinkWidth == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxPcieLinkWidth is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMaxPcieLinkWidth)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4506
 *     global __nvmlDeviceGetMaxPcieLinkWidth
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMaxPcieLinkWidth == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxPcieLinkWidth is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4509
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxPcieLinkWidth is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMaxPcieLinkWidth)(             # <<<<<<<<<<<<<<
 *         device, maxLinkWidth)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxPcieLinkWidth)(__pyx_v_device, __pyx_v_maxLinkWidth);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4503
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMaxPcieLinkWidth(nvmlDevice_t device, unsigned int* maxLinkWidth) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMaxPcieLinkWidth
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetMaxPcieLinkWidth", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4513
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetCurrPcieLinkGeneration(nvmlDevice_t device, unsigned int* currLinkGen) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetCurrPcieLinkGeneration
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetCurrPcieLinkGeneration(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_currLinkGen) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetCurrPcieLinkGeneration", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4515
 * cdef nvmlReturn_t _nvmlDeviceGetCurrPcieLinkGeneration(nvmlDevice_t device, unsigned int* currLinkGen) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetCurrPcieLinkGeneration
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetCurrPcieLinkGeneration == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4515, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4516
 *     global __nvmlDeviceGetCurrPcieLinkGeneration
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCurrPcieLinkGeneration == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCurrPcieLinkGeneration is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrPcieLinkGeneration == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4517
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCurrPcieLinkGeneration == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetCurrPcieLinkGeneration is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetCurrPcieLinkGeneration)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4518
 *     if __nvmlDeviceGetCurrPcieLinkGeneration == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCurrPcieLinkGeneration is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetCurrPcieLinkGeneration)(
 *         device, currLinkGen)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4518, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetCurrPcieLi};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4518, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4518, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4517
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCurrPcieLinkGeneration == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetCurrPcieLinkGeneration is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetCurrPcieLinkGeneration)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4516
 *     global __nvmlDeviceGetCurrPcieLinkGeneration
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCurrPcieLinkGeneration == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCurrPcieLinkGeneration is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4519
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCurrPcieLinkGeneration is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetCurrPcieLinkGeneration)(             # <<<<<<<<<<<<<<
 *         device, currLinkGen)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrPcieLinkGeneration)(__pyx_v_device, __pyx_v_currLinkGen);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4513
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetCurrPcieLinkGeneration(nvmlDevice_t device, unsigned int* currLinkGen) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetCurrPcieLinkGeneration
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetCurrPcieLinkGeneration", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4523
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetCurrPcieLinkWidth(nvmlDevice_t device, unsigned int* currLinkWidth) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetCurrPcieLinkWidth
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetCurrPcieLinkWidth(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_currLinkWidth) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetCurrPcieLinkWidth", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4525
 * cdef nvmlReturn_t _nvmlDeviceGetCurrPcieLinkWidth(nvmlDevice_t device, unsigned int* currLinkWidth) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetCurrPcieLinkWidth
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetCurrPcieLinkWidth == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4525, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4526
 *     global __nvmlDeviceGetCurrPcieLinkWidth
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCurrPcieLinkWidth == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCurrPcieLinkWidth is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrPcieLinkWidth == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4527
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCurrPcieLinkWidth == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetCurrPcieLinkWidth is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetCurrPcieLinkWidth)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4528
 *     if __nvmlDeviceGetCurrPcieLinkWidth == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCurrPcieLinkWidth is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetCurrPcieLinkWidth)(
 *         device, currLinkWidth)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4528, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetCurrPcieLi_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4528, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4528, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4527
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCurrPcieLinkWidth == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetCurrPcieLinkWidth is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetCurrPcieLinkWidth)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4526
 *     global __nvmlDeviceGetCurrPcieLinkWidth
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCurrPcieLinkWidth == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCurrPcieLinkWidth is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4529
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCurrPcieLinkWidth is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetCurrPcieLinkWidth)(             # <<<<<<<<<<<<<<
 *         device, currLinkWidth)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrPcieLinkWidth)(__pyx_v_device, __pyx_v_currLinkWidth);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4523
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetCurrPcieLinkWidth(nvmlDevice_t device, unsigned int* currLinkWidth) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetCurrPcieLinkWidth
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetCurrPcieLinkWidth", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4533
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPcieThroughput(nvmlDevice_t device, nvmlPcieUtilCounter_t counter, unsigned int* value) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPcieThroughput
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPcieThroughput(nvmlDevice_t __pyx_v_device, nvmlPcieUtilCounter_t __pyx_v_counter, unsigned int *__pyx_v_value) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetPcieThroughput", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4535
 * cdef nvmlReturn_t _nvmlDeviceGetPcieThroughput(nvmlDevice_t device, nvmlPcieUtilCounter_t counter, unsigned int* value) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetPcieThroughput
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetPcieThroughput == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4535, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4536
 *     global __nvmlDeviceGetPcieThroughput
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPcieThroughput == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPcieThroughput is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieThroughput == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4537
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPcieThroughput == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPcieThroughput is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPcieUtilCounter_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPcieThroughput)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4538
 *     if __nvmlDeviceGetPcieThroughput == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPcieThroughput is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPcieUtilCounter_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPcieThroughput)(
 *         device, counter, value)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4538, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetPcieThroug};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4538, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4538, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4537
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPcieThroughput == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPcieThroughput is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPcieUtilCounter_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPcieThroughput)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4536
 *     global __nvmlDeviceGetPcieThroughput
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPcieThroughput == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPcieThroughput is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4539
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPcieThroughput is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPcieUtilCounter_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPcieThroughput)(             # <<<<<<<<<<<<<<
 *         device, counter, value)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlPcieUtilCounter_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieThroughput)(__pyx_v_device, __pyx_v_counter, __pyx_v_value);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4533
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPcieThroughput(nvmlDevice_t device, nvmlPcieUtilCounter_t counter, unsigned int* value) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPcieThroughput
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetPcieThroughput", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4543
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPcieReplayCounter(nvmlDevice_t device, unsigned int* value) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPcieReplayCounter
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPcieReplayCounter(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_value) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetPcieReplayCounter", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4545
 * cdef nvmlReturn_t _nvmlDeviceGetPcieReplayCounter(nvmlDevice_t device, unsigned int* value) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetPcieReplayCounter
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetPcieReplayCounter == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4545, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4546
 *     global __nvmlDeviceGetPcieReplayCounter
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPcieReplayCounter == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPcieReplayCounter is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieReplayCounter == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4547
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPcieReplayCounter == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPcieReplayCounter is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPcieReplayCounter)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4548
 *     if __nvmlDeviceGetPcieReplayCounter == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPcieReplayCounter is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPcieReplayCounter)(
 *         device, value)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4548, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetPcieReplay};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4548, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4548, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4547
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPcieReplayCounter == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPcieReplayCounter is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPcieReplayCounter)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4546
 *     global __nvmlDeviceGetPcieReplayCounter
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPcieReplayCounter == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPcieReplayCounter is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4549
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPcieReplayCounter is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPcieReplayCounter)(             # <<<<<<<<<<<<<<
 *         device, value)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieReplayCounter)(__pyx_v_device, __pyx_v_value);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4543
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPcieReplayCounter(nvmlDevice_t device, unsigned int* value) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPcieReplayCounter
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetPcieReplayCounter", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4553
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetClockInfo(nvmlDevice_t device, nvmlClockType_t type, unsigned int* clock) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetClockInfo
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetClockInfo(nvmlDevice_t __pyx_v_device, nvmlClockType_t __pyx_v_type, unsigned int *__pyx_v_clock) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetClockInfo", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4555
 * cdef nvmlReturn_t _nvmlDeviceGetClockInfo(nvmlDevice_t device, nvmlClockType_t type, unsigned int* clock) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetClockInfo
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetClockInfo == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4555, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4556
 *     global __nvmlDeviceGetClockInfo
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetClockInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetClockInfo is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClockInfo == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4557
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetClockInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetClockInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, unsigned int*) noexcept nogil>__nvmlDeviceGetClockInfo)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4558
 *     if __nvmlDeviceGetClockInfo == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetClockInfo is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, unsigned int*) noexcept nogil>__nvmlDeviceGetClockInfo)(
 *         device, type, clock)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4558, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetClockInfo};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4558, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4558, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4557
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetClockInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetClockInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, unsigned int*) noexcept nogil>__nvmlDeviceGetClockInfo)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4556
 *     global __nvmlDeviceGetClockInfo
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetClockInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetClockInfo is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4559
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetClockInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, unsigned int*) noexcept nogil>__nvmlDeviceGetClockInfo)(             # <<<<<<<<<<<<<<
 *         device, type, clock)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClockInfo)(__pyx_v_device, __pyx_v_type, __pyx_v_clock);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4553
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetClockInfo(nvmlDevice_t device, nvmlClockType_t type, unsigned int* clock) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetClockInfo
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetClockInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4563
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMaxClockInfo(nvmlDevice_t device, nvmlClockType_t type, unsigned int* clock) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMaxClockInfo
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMaxClockInfo(nvmlDevice_t __pyx_v_device, nvmlClockType_t __pyx_v_type, unsigned int *__pyx_v_clock) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetMaxClockInfo", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4565
 * cdef nvmlReturn_t _nvmlDeviceGetMaxClockInfo(nvmlDevice_t device, nvmlClockType_t type, unsigned int* clock) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetMaxClockInfo
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetMaxClockInfo == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4565, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4566
 *     global __nvmlDeviceGetMaxClockInfo
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMaxClockInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxClockInfo is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxClockInfo == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4567
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMaxClockInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxClockInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMaxClockInfo)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4568
 *     if __nvmlDeviceGetMaxClockInfo == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxClockInfo is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMaxClockInfo)(
 *         device, type, clock)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4568, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetMaxClockIn};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4568, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4568, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4567
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMaxClockInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxClockInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMaxClockInfo)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4566
 *     global __nvmlDeviceGetMaxClockInfo
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMaxClockInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxClockInfo is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4569
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxClockInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMaxClockInfo)(             # <<<<<<<<<<<<<<
 *         device, type, clock)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxClockInfo)(__pyx_v_device, __pyx_v_type, __pyx_v_clock);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4563
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMaxClockInfo(nvmlDevice_t device, nvmlClockType_t type, unsigned int* clock) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMaxClockInfo
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetMaxClockInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4573
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGpcClkVfOffset(nvmlDevice_t device, int* offset) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGpcClkVfOffset
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGpcClkVfOffset(nvmlDevice_t __pyx_v_device, int *__pyx_v_offset) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetGpcClkVfOffset", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4575
 * cdef nvmlReturn_t _nvmlDeviceGetGpcClkVfOffset(nvmlDevice_t device, int* offset) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetGpcClkVfOffset
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetGpcClkVfOffset == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4575, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4576
 *     global __nvmlDeviceGetGpcClkVfOffset
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpcClkVfOffset == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpcClkVfOffset is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpcClkVfOffset == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4577
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpcClkVfOffset == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpcClkVfOffset is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int*) noexcept nogil>__nvmlDeviceGetGpcClkVfOffset)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4578
 *     if __nvmlDeviceGetGpcClkVfOffset == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpcClkVfOffset is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int*) noexcept nogil>__nvmlDeviceGetGpcClkVfOffset)(
 *         device, offset)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4578, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetGpcClkVfOf};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4578, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4578, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4577
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpcClkVfOffset == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpcClkVfOffset is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int*) noexcept nogil>__nvmlDeviceGetGpcClkVfOffset)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4576
 *     global __nvmlDeviceGetGpcClkVfOffset
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpcClkVfOffset == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpcClkVfOffset is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4579
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpcClkVfOffset is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int*) noexcept nogil>__nvmlDeviceGetGpcClkVfOffset)(             # <<<<<<<<<<<<<<
 *         device, offset)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpcClkVfOffset)(__pyx_v_device, __pyx_v_offset);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4573
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGpcClkVfOffset(nvmlDevice_t device, int* offset) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGpcClkVfOffset
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetGpcClkVfOffset", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4583
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetClock(nvmlDevice_t device, nvmlClockType_t clockType, nvmlClockId_t clockId, unsigned int* clockMHz) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetClock
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetClock(nvmlDevice_t __pyx_v_device, nvmlClockType_t __pyx_v_clockType, nvmlClockId_t __pyx_v_clockId, unsigned int *__pyx_v_clockMHz) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetClock", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4585
 * cdef nvmlReturn_t _nvmlDeviceGetClock(nvmlDevice_t device, nvmlClockType_t clockType, nvmlClockId_t clockId, unsigned int* clockMHz) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetClock
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetClock == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4585, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4586
 *     global __nvmlDeviceGetClock
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetClock == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetClock is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClock == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4587
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetClock == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetClock is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, nvmlClockId_t, unsigned int*) noexcept nogil>__nvmlDeviceGetClock)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4588
 *     if __nvmlDeviceGetClock == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetClock is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, nvmlClockId_t, unsigned int*) noexcept nogil>__nvmlDeviceGetClock)(
 *         device, clockType, clockId, clockMHz)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4588, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetClock_is_n};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4588, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4588, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4587
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetClock == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetClock is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, nvmlClockId_t, unsigned int*) noexcept nogil>__nvmlDeviceGetClock)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4586
 *     global __nvmlDeviceGetClock
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetClock == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetClock is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4589
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetClock is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, nvmlClockId_t, unsigned int*) noexcept nogil>__nvmlDeviceGetClock)(             # <<<<<<<<<<<<<<
 *         device, clockType, clockId, clockMHz)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, nvmlClockId_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClock)(__pyx_v_device, __pyx_v_clockType, __pyx_v_clockId, __pyx_v_clockMHz);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4583
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetClock(nvmlDevice_t device, nvmlClockType_t clockType, nvmlClockId_t clockId, unsigned int* clockMHz) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetClock
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetClock", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4593
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMaxCustomerBoostClock(nvmlDevice_t device, nvmlClockType_t clockType, unsigned int* clockMHz) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMaxCustomerBoostClock
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMaxCustomerBoostClock(nvmlDevice_t __pyx_v_device, nvmlClockType_t __pyx_v_clockType, unsigned int *__pyx_v_clockMHz) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetMaxCustomerBoostClock", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4595
 * cdef nvmlReturn_t _nvmlDeviceGetMaxCustomerBoostClock(nvmlDevice_t device, nvmlClockType_t clockType, unsigned int* clockMHz) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetMaxCustomerBoostClock
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetMaxCustomerBoostClock == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4595, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4596
 *     global __nvmlDeviceGetMaxCustomerBoostClock
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMaxCustomerBoostClock == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxCustomerBoostClock is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxCustomerBoostClock == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4597
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMaxCustomerBoostClock == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxCustomerBoostClock is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMaxCustomerBoostClock)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4598
 *     if __nvmlDeviceGetMaxCustomerBoostClock == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxCustomerBoostClock is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMaxCustomerBoostClock)(
 *         device, clockType, clockMHz)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4598, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetMaxCustome};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4598, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4598, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4597
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMaxCustomerBoostClock == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxCustomerBoostClock is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMaxCustomerBoostClock)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4596
 *     global __nvmlDeviceGetMaxCustomerBoostClock
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMaxCustomerBoostClock == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxCustomerBoostClock is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4599
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxCustomerBoostClock is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMaxCustomerBoostClock)(             # <<<<<<<<<<<<<<
 *         device, clockType, clockMHz)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxCustomerBoostClock)(__pyx_v_device, __pyx_v_clockType, __pyx_v_clockMHz);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4593
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMaxCustomerBoostClock(nvmlDevice_t device, nvmlClockType_t clockType, unsigned int* clockMHz) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMaxCustomerBoostClock
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetMaxCustomerBoostClock", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4603
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetSupportedMemoryClocks(nvmlDevice_t device, unsigned int* count, unsigned int* clocksMHz) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetSupportedMemoryClocks
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetSupportedMemoryClocks(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_count, unsigned int *__pyx_v_clocksMHz) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetSupportedMemoryClocks", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4605
 * cdef nvmlReturn_t _nvmlDeviceGetSupportedMemoryClocks(nvmlDevice_t device, unsigned int* count, unsigned int* clocksMHz) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetSupportedMemoryClocks
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetSupportedMemoryClocks == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4605, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4606
 *     global __nvmlDeviceGetSupportedMemoryClocks
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSupportedMemoryClocks == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedMemoryClocks is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedMemoryClocks == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4607
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSupportedMemoryClocks == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedMemoryClocks is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetSupportedMemoryClocks)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4608
 *     if __nvmlDeviceGetSupportedMemoryClocks == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedMemoryClocks is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetSupportedMemoryClocks)(
 *         device, count, clocksMHz)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4608, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetSupportedM};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4608, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4608, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4607
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSupportedMemoryClocks == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedMemoryClocks is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetSupportedMemoryClocks)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4606
 *     global __nvmlDeviceGetSupportedMemoryClocks
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSupportedMemoryClocks == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedMemoryClocks is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4609
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedMemoryClocks is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetSupportedMemoryClocks)(             # <<<<<<<<<<<<<<
 *         device, count, clocksMHz)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedMemoryClocks)(__pyx_v_device, __pyx_v_count, __pyx_v_clocksMHz);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4603
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetSupportedMemoryClocks(nvmlDevice_t device, unsigned int* count, unsigned int* clocksMHz) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetSupportedMemoryClocks
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetSupportedMemoryClocks", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4613
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetSupportedGraphicsClocks(nvmlDevice_t device, unsigned int memoryClockMHz, unsigned int* count, unsigned int* clocksMHz) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetSupportedGraphicsClocks
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetSupportedGraphicsClocks(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_memoryClockMHz, unsigned int *__pyx_v_count, unsigned int *__pyx_v_clocksMHz) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetSupportedGraphicsClocks", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4615
 * cdef nvmlReturn_t _nvmlDeviceGetSupportedGraphicsClocks(nvmlDevice_t device, unsigned int memoryClockMHz, unsigned int* count, unsigned int* clocksMHz) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetSupportedGraphicsClocks
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetSupportedGraphicsClocks == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4615, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4616
 *     global __nvmlDeviceGetSupportedGraphicsClocks
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSupportedGraphicsClocks == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedGraphicsClocks is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedGraphicsClocks == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4617
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSupportedGraphicsClocks == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedGraphicsClocks is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetSupportedGraphicsClocks)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4618
 *     if __nvmlDeviceGetSupportedGraphicsClocks == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedGraphicsClocks is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetSupportedGraphicsClocks)(
 *         device, memoryClockMHz, count, clocksMHz)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4618, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetSupportedG};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4618, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4618, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4617
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSupportedGraphicsClocks == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedGraphicsClocks is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetSupportedGraphicsClocks)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4616
 *     global __nvmlDeviceGetSupportedGraphicsClocks
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSupportedGraphicsClocks == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedGraphicsClocks is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4619
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedGraphicsClocks is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetSupportedGraphicsClocks)(             # <<<<<<<<<<<<<<
 *         device, memoryClockMHz, count, clocksMHz)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedGraphicsClocks)(__pyx_v_device, __pyx_v_memoryClockMHz, __pyx_v_count, __pyx_v_clocksMHz);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4613
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetSupportedGraphicsClocks(nvmlDevice_t device, unsigned int memoryClockMHz, unsigned int* count, unsigned int* clocksMHz) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetSupportedGraphicsClocks
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetSupportedGraphicsClocks", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4623
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetAutoBoostedClocksEnabled(nvmlDevice_t device, nvmlEnableState_t* isEnabled, nvmlEnableState_t* defaultIsEnabled) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetAutoBoostedClocksEnabled
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetAutoBoostedClocksEnabled(nvmlDevice_t __pyx_v_device, nvmlEnableState_t *__pyx_v_isEnabled, nvmlEnableState_t *__pyx_v_defaultIsEnabled) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetAutoBoostedClocksEnabled", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4625
 * cdef nvmlReturn_t _nvmlDeviceGetAutoBoostedClocksEnabled(nvmlDevice_t device, nvmlEnableState_t* isEnabled, nvmlEnableState_t* defaultIsEnabled) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetAutoBoostedClocksEnabled
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetAutoBoostedClocksEnabled == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4625, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4626
 *     global __nvmlDeviceGetAutoBoostedClocksEnabled
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAutoBoostedClocksEnabled == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAutoBoostedClocksEnabled is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAutoBoostedClocksEnabled == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4627
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAutoBoostedClocksEnabled == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetAutoBoostedClocksEnabled is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetAutoBoostedClocksEnabled)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4628
 *     if __nvmlDeviceGetAutoBoostedClocksEnabled == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAutoBoostedClocksEnabled is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetAutoBoostedClocksEnabled)(
 *         device, isEnabled, defaultIsEnabled)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4628, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetAutoBooste};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4628, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4628, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4627
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAutoBoostedClocksEnabled == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetAutoBoostedClocksEnabled is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetAutoBoostedClocksEnabled)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4626
 *     global __nvmlDeviceGetAutoBoostedClocksEnabled
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAutoBoostedClocksEnabled == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAutoBoostedClocksEnabled is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4629
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAutoBoostedClocksEnabled is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetAutoBoostedClocksEnabled)(             # <<<<<<<<<<<<<<
 *         device, isEnabled, defaultIsEnabled)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t *, nvmlEnableState_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAutoBoostedClocksEnabled)(__pyx_v_device, __pyx_v_isEnabled, __pyx_v_defaultIsEnabled);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4623
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetAutoBoostedClocksEnabled(nvmlDevice_t device, nvmlEnableState_t* isEnabled, nvmlEnableState_t* defaultIsEnabled) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetAutoBoostedClocksEnabled
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetAutoBoostedClocksEnabled", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4633
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetFanSpeed(nvmlDevice_t device, unsigned int* speed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetFanSpeed
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetFanSpeed(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_speed) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetFanSpeed", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4635
 * cdef nvmlReturn_t _nvmlDeviceGetFanSpeed(nvmlDevice_t device, unsigned int* speed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetFanSpeed
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetFanSpeed == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4635, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4636
 *     global __nvmlDeviceGetFanSpeed
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFanSpeed == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFanSpeed is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanSpeed == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4637
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFanSpeed == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetFanSpeed is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetFanSpeed)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4638
 *     if __nvmlDeviceGetFanSpeed == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFanSpeed is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetFanSpeed)(
 *         device, speed)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4638, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetFanSpeed_i};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4638, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4638, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4637
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFanSpeed == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetFanSpeed is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetFanSpeed)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4636
 *     global __nvmlDeviceGetFanSpeed
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFanSpeed == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFanSpeed is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4639
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFanSpeed is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetFanSpeed)(             # <<<<<<<<<<<<<<
 *         device, speed)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanSpeed)(__pyx_v_device, __pyx_v_speed);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4633
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetFanSpeed(nvmlDevice_t device, unsigned int* speed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetFanSpeed
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetFanSpeed", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4643
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetFanSpeed_v2(nvmlDevice_t device, unsigned int fan, unsigned int* speed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetFanSpeed_v2
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetFanSpeed_v2(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_fan, unsigned int *__pyx_v_speed) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetFanSpeed_v2", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4645
 * cdef nvmlReturn_t _nvmlDeviceGetFanSpeed_v2(nvmlDevice_t device, unsigned int fan, unsigned int* speed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetFanSpeed_v2
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetFanSpeed_v2 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4645, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4646
 *     global __nvmlDeviceGetFanSpeed_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFanSpeed_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFanSpeed_v2 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanSpeed_v2 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4647
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFanSpeed_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetFanSpeed_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int*) noexcept nogil>__nvmlDeviceGetFanSpeed_v2)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4648
 *     if __nvmlDeviceGetFanSpeed_v2 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFanSpeed_v2 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int*) noexcept nogil>__nvmlDeviceGetFanSpeed_v2)(
 *         device, fan, speed)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4648, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetFanSpeed_v};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4648, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4648, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4647
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFanSpeed_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetFanSpeed_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int*) noexcept nogil>__nvmlDeviceGetFanSpeed_v2)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4646
 *     global __nvmlDeviceGetFanSpeed_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFanSpeed_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFanSpeed_v2 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4649
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFanSpeed_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int*) noexcept nogil>__nvmlDeviceGetFanSpeed_v2)(             # <<<<<<<<<<<<<<
 *         device, fan, speed)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanSpeed_v2)(__pyx_v_device, __pyx_v_fan, __pyx_v_speed);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4643
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetFanSpeed_v2(nvmlDevice_t device, unsigned int fan, unsigned int* speed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetFanSpeed_v2
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetFanSpeed_v2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4653
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetFanSpeedRPM(nvmlDevice_t device, nvmlFanSpeedInfo_t* fanSpeed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetFanSpeedRPM
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetFanSpeedRPM(nvmlDevice_t __pyx_v_device, nvmlFanSpeedInfo_t *__pyx_v_fanSpeed) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetFanSpeedRPM", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4655
 * cdef nvmlReturn_t _nvmlDeviceGetFanSpeedRPM(nvmlDevice_t device, nvmlFanSpeedInfo_t* fanSpeed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetFanSpeedRPM
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetFanSpeedRPM == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4655, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4656
 *     global __nvmlDeviceGetFanSpeedRPM
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFanSpeedRPM == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFanSpeedRPM is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanSpeedRPM == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4657
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFanSpeedRPM == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetFanSpeedRPM is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlFanSpeedInfo_t*) noexcept nogil>__nvmlDeviceGetFanSpeedRPM)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4658
 *     if __nvmlDeviceGetFanSpeedRPM == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFanSpeedRPM is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlFanSpeedInfo_t*) noexcept nogil>__nvmlDeviceGetFanSpeedRPM)(
 *         device, fanSpeed)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4658, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetFanSpeedRP};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4658, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4658, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4657
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFanSpeedRPM == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetFanSpeedRPM is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlFanSpeedInfo_t*) noexcept nogil>__nvmlDeviceGetFanSpeedRPM)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4656
 *     global __nvmlDeviceGetFanSpeedRPM
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFanSpeedRPM == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFanSpeedRPM is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4659
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFanSpeedRPM is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlFanSpeedInfo_t*) noexcept nogil>__nvmlDeviceGetFanSpeedRPM)(             # <<<<<<<<<<<<<<
 *         device, fanSpeed)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlFanSpeedInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanSpeedRPM)(__pyx_v_device, __pyx_v_fanSpeed);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4653
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetFanSpeedRPM(nvmlDevice_t device, nvmlFanSpeedInfo_t* fanSpeed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetFanSpeedRPM
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetFanSpeedRPM", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4663
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetTargetFanSpeed(nvmlDevice_t device, unsigned int fan, unsigned int* targetSpeed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetTargetFanSpeed
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetTargetFanSpeed(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_fan, unsigned int *__pyx_v_targetSpeed) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetTargetFanSpeed", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4665
 * cdef nvmlReturn_t _nvmlDeviceGetTargetFanSpeed(nvmlDevice_t device, unsigned int fan, unsigned int* targetSpeed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetTargetFanSpeed
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetTargetFanSpeed == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4665, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4666
 *     global __nvmlDeviceGetTargetFanSpeed
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTargetFanSpeed == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTargetFanSpeed is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTargetFanSpeed == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4667
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTargetFanSpeed == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetTargetFanSpeed is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int*) noexcept nogil>__nvmlDeviceGetTargetFanSpeed)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4668
 *     if __nvmlDeviceGetTargetFanSpeed == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTargetFanSpeed is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int*) noexcept nogil>__nvmlDeviceGetTargetFanSpeed)(
 *         device, fan, targetSpeed)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4668, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetTargetFanS};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4668, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4668, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4667
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTargetFanSpeed == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetTargetFanSpeed is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int*) noexcept nogil>__nvmlDeviceGetTargetFanSpeed)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4666
 *     global __nvmlDeviceGetTargetFanSpeed
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTargetFanSpeed == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTargetFanSpeed is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4669
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTargetFanSpeed is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int*) noexcept nogil>__nvmlDeviceGetTargetFanSpeed)(             # <<<<<<<<<<<<<<
 *         device, fan, targetSpeed)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTargetFanSpeed)(__pyx_v_device, __pyx_v_fan, __pyx_v_targetSpeed);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4663
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetTargetFanSpeed(nvmlDevice_t device, unsigned int fan, unsigned int* targetSpeed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetTargetFanSpeed
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetTargetFanSpeed", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4673
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMinMaxFanSpeed(nvmlDevice_t device, unsigned int* minSpeed, unsigned int* maxSpeed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMinMaxFanSpeed
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMinMaxFanSpeed(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_minSpeed, unsigned int *__pyx_v_maxSpeed) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetMinMaxFanSpeed", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4675
 * cdef nvmlReturn_t _nvmlDeviceGetMinMaxFanSpeed(nvmlDevice_t device, unsigned int* minSpeed, unsigned int* maxSpeed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetMinMaxFanSpeed
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetMinMaxFanSpeed == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4675, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4676
 *     global __nvmlDeviceGetMinMaxFanSpeed
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMinMaxFanSpeed == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMinMaxFanSpeed is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMinMaxFanSpeed == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4677
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMinMaxFanSpeed == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMinMaxFanSpeed is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetMinMaxFanSpeed)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4678
 *     if __nvmlDeviceGetMinMaxFanSpeed == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMinMaxFanSpeed is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetMinMaxFanSpeed)(
 *         device, minSpeed, maxSpeed)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4678, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetMinMaxFanS};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4678, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4678, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4677
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMinMaxFanSpeed == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMinMaxFanSpeed is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetMinMaxFanSpeed)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4676
 *     global __nvmlDeviceGetMinMaxFanSpeed
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMinMaxFanSpeed == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMinMaxFanSpeed is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4679
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMinMaxFanSpeed is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetMinMaxFanSpeed)(             # <<<<<<<<<<<<<<
 *         device, minSpeed, maxSpeed)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMinMaxFanSpeed)(__pyx_v_device, __pyx_v_minSpeed, __pyx_v_maxSpeed);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4673
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMinMaxFanSpeed(nvmlDevice_t device, unsigned int* minSpeed, unsigned int* maxSpeed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMinMaxFanSpeed
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetMinMaxFanSpeed", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4683
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetFanControlPolicy_v2(nvmlDevice_t device, unsigned int fan, nvmlFanControlPolicy_t* policy) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetFanControlPolicy_v2
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetFanControlPolicy_v2(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_fan, nvmlFanControlPolicy_t *__pyx_v_policy) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetFanControlPolicy_v2", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4685
 * cdef nvmlReturn_t _nvmlDeviceGetFanControlPolicy_v2(nvmlDevice_t device, unsigned int fan, nvmlFanControlPolicy_t* policy) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetFanControlPolicy_v2
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetFanControlPolicy_v2 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4685, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4686
 *     global __nvmlDeviceGetFanControlPolicy_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFanControlPolicy_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFanControlPolicy_v2 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanControlPolicy_v2 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4687
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFanControlPolicy_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetFanControlPolicy_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlFanControlPolicy_t*) noexcept nogil>__nvmlDeviceGetFanControlPolicy_v2)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4688
 *     if __nvmlDeviceGetFanControlPolicy_v2 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFanControlPolicy_v2 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlFanControlPolicy_t*) noexcept nogil>__nvmlDeviceGetFanControlPolicy_v2)(
 *         device, fan, policy)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4688, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetFanControl};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4688, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4688, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4687
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFanControlPolicy_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetFanControlPolicy_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlFanControlPolicy_t*) noexcept nogil>__nvmlDeviceGetFanControlPolicy_v2)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4686
 *     global __nvmlDeviceGetFanControlPolicy_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFanControlPolicy_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFanControlPolicy_v2 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4689
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFanControlPolicy_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlFanControlPolicy_t*) noexcept nogil>__nvmlDeviceGetFanControlPolicy_v2)(             # <<<<<<<<<<<<<<
 *         device, fan, policy)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlFanControlPolicy_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanControlPolicy_v2)(__pyx_v_device, __pyx_v_fan, __pyx_v_policy);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4683
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetFanControlPolicy_v2(nvmlDevice_t device, unsigned int fan, nvmlFanControlPolicy_t* policy) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetFanControlPolicy_v2
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetFanControlPolicy_v2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4693
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetNumFans(nvmlDevice_t device, unsigned int* numFans) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetNumFans
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetNumFans(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_numFans) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetNumFans", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4695
 * cdef nvmlReturn_t _nvmlDeviceGetNumFans(nvmlDevice_t device, unsigned int* numFans) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetNumFans
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetNumFans == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4695, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4696
 *     global __nvmlDeviceGetNumFans
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNumFans == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNumFans is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNumFans == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4697
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNumFans == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetNumFans is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetNumFans)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4698
 *     if __nvmlDeviceGetNumFans == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNumFans is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetNumFans)(
 *         device, numFans)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4698, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetNumFans_is};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4698, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4698, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4697
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNumFans == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetNumFans is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetNumFans)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4696
 *     global __nvmlDeviceGetNumFans
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNumFans == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNumFans is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4699
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNumFans is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetNumFans)(             # <<<<<<<<<<<<<<
 *         device, numFans)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNumFans)(__pyx_v_device, __pyx_v_numFans);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4693
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetNumFans(nvmlDevice_t device, unsigned int* numFans) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetNumFans
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetNumFans", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4703
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetCoolerInfo(nvmlDevice_t device, nvmlCoolerInfo_t* coolerInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetCoolerInfo
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetCoolerInfo(nvmlDevice_t __pyx_v_device, nvmlCoolerInfo_t *__pyx_v_coolerInfo) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetCoolerInfo", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4705
 * cdef nvmlReturn_t _nvmlDeviceGetCoolerInfo(nvmlDevice_t device, nvmlCoolerInfo_t* coolerInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetCoolerInfo
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetCoolerInfo == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4705, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4706
 *     global __nvmlDeviceGetCoolerInfo
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCoolerInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCoolerInfo is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCoolerInfo == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4707
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCoolerInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetCoolerInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlCoolerInfo_t*) noexcept nogil>__nvmlDeviceGetCoolerInfo)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4708
 *     if __nvmlDeviceGetCoolerInfo == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCoolerInfo is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlCoolerInfo_t*) noexcept nogil>__nvmlDeviceGetCoolerInfo)(
 *         device, coolerInfo)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4708, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetCoolerInfo};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4708, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4708, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4707
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCoolerInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetCoolerInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlCoolerInfo_t*) noexcept nogil>__nvmlDeviceGetCoolerInfo)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4706
 *     global __nvmlDeviceGetCoolerInfo
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCoolerInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCoolerInfo is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4709
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCoolerInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlCoolerInfo_t*) noexcept nogil>__nvmlDeviceGetCoolerInfo)(             # <<<<<<<<<<<<<<
 *         device, coolerInfo)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlCoolerInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCoolerInfo)(__pyx_v_device, __pyx_v_coolerInfo);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4703
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetCoolerInfo(nvmlDevice_t device, nvmlCoolerInfo_t* coolerInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetCoolerInfo
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetCoolerInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4713
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetTemperatureV(nvmlDevice_t device, nvmlTemperature_t* temperature) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetTemperatureV
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetTemperatureV(nvmlDevice_t __pyx_v_device, nvmlTemperature_t *__pyx_v_temperature) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetTemperatureV", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4715
 * cdef nvmlReturn_t _nvmlDeviceGetTemperatureV(nvmlDevice_t device, nvmlTemperature_t* temperature) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetTemperatureV
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetTemperatureV == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4715, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4716
 *     global __nvmlDeviceGetTemperatureV
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTemperatureV == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTemperatureV is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTemperatureV == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4717
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTemperatureV == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetTemperatureV is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlTemperature_t*) noexcept nogil>__nvmlDeviceGetTemperatureV)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4718
 *     if __nvmlDeviceGetTemperatureV == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTemperatureV is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlTemperature_t*) noexcept nogil>__nvmlDeviceGetTemperatureV)(
 *         device, temperature)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4718, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetTemperatur};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4718, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4718, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4717
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTemperatureV == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetTemperatureV is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlTemperature_t*) noexcept nogil>__nvmlDeviceGetTemperatureV)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4716
 *     global __nvmlDeviceGetTemperatureV
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTemperatureV == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTemperatureV is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4719
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTemperatureV is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlTemperature_t*) noexcept nogil>__nvmlDeviceGetTemperatureV)(             # <<<<<<<<<<<<<<
 *         device, temperature)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlTemperature_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTemperatureV)(__pyx_v_device, __pyx_v_temperature);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4713
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetTemperatureV(nvmlDevice_t device, nvmlTemperature_t* temperature) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetTemperatureV
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetTemperatureV", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4723
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetTemperatureThreshold(nvmlDevice_t device, nvmlTemperatureThresholds_t thresholdType, unsigned int* temp) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetTemperatureThreshold
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetTemperatureThreshold(nvmlDevice_t __pyx_v_device, nvmlTemperatureThresholds_t __pyx_v_thresholdType, unsigned int *__pyx_v_temp) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetTemperatureThreshold", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4725
 * cdef nvmlReturn_t _nvmlDeviceGetTemperatureThreshold(nvmlDevice_t device, nvmlTemperatureThresholds_t thresholdType, unsigned int* temp) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetTemperatureThreshold
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetTemperatureThreshold == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4725, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4726
 *     global __nvmlDeviceGetTemperatureThreshold
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTemperatureThreshold == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTemperatureThreshold is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTemperatureThreshold == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4727
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTemperatureThreshold == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetTemperatureThreshold is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlTemperatureThresholds_t, unsigned int*) noexcept nogil>__nvmlDeviceGetTemperatureThreshold)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4728
 *     if __nvmlDeviceGetTemperatureThreshold == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTemperatureThreshold is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlTemperatureThresholds_t, unsigned int*) noexcept nogil>__nvmlDeviceGetTemperatureThreshold)(
 *         device, thresholdType, temp)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4728, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetTemperatur_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4728, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4728, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4727
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTemperatureThreshold == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetTemperatureThreshold is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlTemperatureThresholds_t, unsigned int*) noexcept nogil>__nvmlDeviceGetTemperatureThreshold)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4726
 *     global __nvmlDeviceGetTemperatureThreshold
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTemperatureThreshold == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTemperatureThreshold is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4729
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTemperatureThreshold is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlTemperatureThresholds_t, unsigned int*) noexcept nogil>__nvmlDeviceGetTemperatureThreshold)(             # <<<<<<<<<<<<<<
 *         device, thresholdType, temp)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlTemperatureThresholds_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTemperatureThreshold)(__pyx_v_device, __pyx_v_thresholdType, __pyx_v_temp);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4723
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetTemperatureThreshold(nvmlDevice_t device, nvmlTemperatureThresholds_t thresholdType, unsigned int* temp) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetTemperatureThreshold
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetTemperatureThreshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4733
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMarginTemperature(nvmlDevice_t device, nvmlMarginTemperature_t* marginTempInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMarginTemperature
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMarginTemperature(nvmlDevice_t __pyx_v_device, nvmlMarginTemperature_t *__pyx_v_marginTempInfo) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetMarginTemperature", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4735
 * cdef nvmlReturn_t _nvmlDeviceGetMarginTemperature(nvmlDevice_t device, nvmlMarginTemperature_t* marginTempInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetMarginTemperature
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetMarginTemperature == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4735, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4736
 *     global __nvmlDeviceGetMarginTemperature
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMarginTemperature == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMarginTemperature is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMarginTemperature == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4737
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMarginTemperature == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMarginTemperature is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlMarginTemperature_t*) noexcept nogil>__nvmlDeviceGetMarginTemperature)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4738
 *     if __nvmlDeviceGetMarginTemperature == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMarginTemperature is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlMarginTemperature_t*) noexcept nogil>__nvmlDeviceGetMarginTemperature)(
 *         device, marginTempInfo)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4738, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetMarginTemp};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4738, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4738, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4737
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMarginTemperature == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMarginTemperature is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlMarginTemperature_t*) noexcept nogil>__nvmlDeviceGetMarginTemperature)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4736
 *     global __nvmlDeviceGetMarginTemperature
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMarginTemperature == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMarginTemperature is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4739
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMarginTemperature is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlMarginTemperature_t*) noexcept nogil>__nvmlDeviceGetMarginTemperature)(             # <<<<<<<<<<<<<<
 *         device, marginTempInfo)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlMarginTemperature_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMarginTemperature)(__pyx_v_device, __pyx_v_marginTempInfo);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4733
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMarginTemperature(nvmlDevice_t device, nvmlMarginTemperature_t* marginTempInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMarginTemperature
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetMarginTemperature", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4743
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetThermalSettings(nvmlDevice_t device, unsigned int sensorIndex, nvmlGpuThermalSettings_t* pThermalSettings) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetThermalSettings
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetThermalSettings(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_sensorIndex, nvmlGpuThermalSettings_t *__pyx_v_pThermalSettings) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetThermalSettings", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4745
 * cdef nvmlReturn_t _nvmlDeviceGetThermalSettings(nvmlDevice_t device, unsigned int sensorIndex, nvmlGpuThermalSettings_t* pThermalSettings) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetThermalSettings
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetThermalSettings == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4745, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4746
 *     global __nvmlDeviceGetThermalSettings
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetThermalSettings == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetThermalSettings is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetThermalSettings == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4747
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetThermalSettings == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetThermalSettings is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuThermalSettings_t*) noexcept nogil>__nvmlDeviceGetThermalSettings)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4748
 *     if __nvmlDeviceGetThermalSettings == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetThermalSettings is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuThermalSettings_t*) noexcept nogil>__nvmlDeviceGetThermalSettings)(
 *         device, sensorIndex, pThermalSettings)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4748, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetThermalSet};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4748, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4748, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4747
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetThermalSettings == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetThermalSettings is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuThermalSettings_t*) noexcept nogil>__nvmlDeviceGetThermalSettings)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4746
 *     global __nvmlDeviceGetThermalSettings
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetThermalSettings == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetThermalSettings is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4749
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetThermalSettings is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuThermalSettings_t*) noexcept nogil>__nvmlDeviceGetThermalSettings)(             # <<<<<<<<<<<<<<
 *         device, sensorIndex, pThermalSettings)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuThermalSettings_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetThermalSettings)(__pyx_v_device, __pyx_v_sensorIndex, __pyx_v_pThermalSettings);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4743
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetThermalSettings(nvmlDevice_t device, unsigned int sensorIndex, nvmlGpuThermalSettings_t* pThermalSettings) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetThermalSettings
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetThermalSettings", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4753
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPerformanceState(nvmlDevice_t device, nvmlPstates_t* pState) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPerformanceState
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPerformanceState(nvmlDevice_t __pyx_v_device, nvmlPstates_t *__pyx_v_pState) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetPerformanceState", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4755
 * cdef nvmlReturn_t _nvmlDeviceGetPerformanceState(nvmlDevice_t device, nvmlPstates_t* pState) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetPerformanceState
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetPerformanceState == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4755, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4756
 *     global __nvmlDeviceGetPerformanceState
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPerformanceState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPerformanceState is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPerformanceState == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4757
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPerformanceState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPerformanceState is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPstates_t*) noexcept nogil>__nvmlDeviceGetPerformanceState)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4758
 *     if __nvmlDeviceGetPerformanceState == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPerformanceState is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPstates_t*) noexcept nogil>__nvmlDeviceGetPerformanceState)(
 *         device, pState)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4758, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetPerformanc};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4758, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4758, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4757
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPerformanceState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPerformanceState is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPstates_t*) noexcept nogil>__nvmlDeviceGetPerformanceState)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4756
 *     global __nvmlDeviceGetPerformanceState
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPerformanceState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPerformanceState is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4759
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPerformanceState is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPstates_t*) noexcept nogil>__nvmlDeviceGetPerformanceState)(             # <<<<<<<<<<<<<<
 *         device, pState)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlPstates_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPerformanceState)(__pyx_v_device, __pyx_v_pState);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4753
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPerformanceState(nvmlDevice_t device, nvmlPstates_t* pState) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPerformanceState
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetPerformanceState", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4763
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetCurrentClocksEventReasons(nvmlDevice_t device, unsigned long long* clocksEventReasons) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetCurrentClocksEventReasons
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetCurrentClocksEventReasons(nvmlDevice_t __pyx_v_device, unsigned PY_LONG_LONG *__pyx_v_clocksEventReasons) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetCurrentClocksEventReasons", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4765
 * cdef nvmlReturn_t _nvmlDeviceGetCurrentClocksEventReasons(nvmlDevice_t device, unsigned long long* clocksEventReasons) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetCurrentClocksEventReasons
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetCurrentClocksEventReasons == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4765, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4766
 *     global __nvmlDeviceGetCurrentClocksEventReasons
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCurrentClocksEventReasons == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCurrentClocksEventReasons is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrentClocksEventReasons == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4767
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCurrentClocksEventReasons == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetCurrentClocksEventReasons is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetCurrentClocksEventReasons)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4768
 *     if __nvmlDeviceGetCurrentClocksEventReasons == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCurrentClocksEventReasons is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetCurrentClocksEventReasons)(
 *         device, clocksEventReasons)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4768, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetCurrentClo};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4768, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4768, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4767
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCurrentClocksEventReasons == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetCurrentClocksEventReasons is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetCurrentClocksEventReasons)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4766
 *     global __nvmlDeviceGetCurrentClocksEventReasons
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCurrentClocksEventReasons == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCurrentClocksEventReasons is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4769
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCurrentClocksEventReasons is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetCurrentClocksEventReasons)(             # <<<<<<<<<<<<<<
 *         device, clocksEventReasons)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned PY_LONG_LONG *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrentClocksEventReasons)(__pyx_v_device, __pyx_v_clocksEventReasons);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4763
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetCurrentClocksEventReasons(nvmlDevice_t device, unsigned long long* clocksEventReasons) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetCurrentClocksEventReasons
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetCurrentClocksEventReasons", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4773
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetSupportedClocksEventReasons(nvmlDevice_t device, unsigned long long* supportedClocksEventReasons) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetSupportedClocksEventReasons
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetSupportedClocksEventReasons(nvmlDevice_t __pyx_v_device, unsigned PY_LONG_LONG *__pyx_v_supportedClocksEventReasons) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetSupportedClocksEventReasons", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4775
 * cdef nvmlReturn_t _nvmlDeviceGetSupportedClocksEventReasons(nvmlDevice_t device, unsigned long long* supportedClocksEventReasons) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetSupportedClocksEventReasons
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetSupportedClocksEventReasons == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4775, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4776
 *     global __nvmlDeviceGetSupportedClocksEventReasons
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSupportedClocksEventReasons == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedClocksEventReasons is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedClocksEventReasons == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4777
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSupportedClocksEventReasons == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedClocksEventReasons is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetSupportedClocksEventReasons)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4778
 *     if __nvmlDeviceGetSupportedClocksEventReasons == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedClocksEventReasons is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetSupportedClocksEventReasons)(
 *         device, supportedClocksEventReasons)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4778, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetSupportedC};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4778, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4778, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4777
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSupportedClocksEventReasons == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedClocksEventReasons is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetSupportedClocksEventReasons)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4776
 *     global __nvmlDeviceGetSupportedClocksEventReasons
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSupportedClocksEventReasons == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedClocksEventReasons is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4779
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedClocksEventReasons is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetSupportedClocksEventReasons)(             # <<<<<<<<<<<<<<
 *         device, supportedClocksEventReasons)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned PY_LONG_LONG *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedClocksEventReasons)(__pyx_v_device, __pyx_v_supportedClocksEventReasons);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4773
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetSupportedClocksEventReasons(nvmlDevice_t device, unsigned long long* supportedClocksEventReasons) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetSupportedClocksEventReasons
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetSupportedClocksEventReasons", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4783
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPowerState(nvmlDevice_t device, nvmlPstates_t* pState) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPowerState
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPowerState(nvmlDevice_t __pyx_v_device, nvmlPstates_t *__pyx_v_pState) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetPowerState", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4785
 * cdef nvmlReturn_t _nvmlDeviceGetPowerState(nvmlDevice_t device, nvmlPstates_t* pState) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetPowerState
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetPowerState == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4785, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4786
 *     global __nvmlDeviceGetPowerState
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerState is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerState == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4787
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerState is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPstates_t*) noexcept nogil>__nvmlDeviceGetPowerState)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4788
 *     if __nvmlDeviceGetPowerState == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerState is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPstates_t*) noexcept nogil>__nvmlDeviceGetPowerState)(
 *         device, pState)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4788, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetPowerState};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4788, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4788, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4787
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerState is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPstates_t*) noexcept nogil>__nvmlDeviceGetPowerState)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4786
 *     global __nvmlDeviceGetPowerState
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerState is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4789
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerState is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPstates_t*) noexcept nogil>__nvmlDeviceGetPowerState)(             # <<<<<<<<<<<<<<
 *         device, pState)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlPstates_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerState)(__pyx_v_device, __pyx_v_pState);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4783
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPowerState(nvmlDevice_t device, nvmlPstates_t* pState) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPowerState
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetPowerState", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4793
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetDynamicPstatesInfo(nvmlDevice_t device, nvmlGpuDynamicPstatesInfo_t* pDynamicPstatesInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetDynamicPstatesInfo
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetDynamicPstatesInfo(nvmlDevice_t __pyx_v_device, nvmlGpuDynamicPstatesInfo_t *__pyx_v_pDynamicPstatesInfo) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetDynamicPstatesInfo", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4795
 * cdef nvmlReturn_t _nvmlDeviceGetDynamicPstatesInfo(nvmlDevice_t device, nvmlGpuDynamicPstatesInfo_t* pDynamicPstatesInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetDynamicPstatesInfo
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetDynamicPstatesInfo == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4795, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4796
 *     global __nvmlDeviceGetDynamicPstatesInfo
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDynamicPstatesInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDynamicPstatesInfo is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDynamicPstatesInfo == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4797
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDynamicPstatesInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetDynamicPstatesInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuDynamicPstatesInfo_t*) noexcept nogil>__nvmlDeviceGetDynamicPstatesInfo)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4798
 *     if __nvmlDeviceGetDynamicPstatesInfo == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDynamicPstatesInfo is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuDynamicPstatesInfo_t*) noexcept nogil>__nvmlDeviceGetDynamicPstatesInfo)(
 *         device, pDynamicPstatesInfo)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4798, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetDynamicPst};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4798, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4798, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4797
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDynamicPstatesInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetDynamicPstatesInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuDynamicPstatesInfo_t*) noexcept nogil>__nvmlDeviceGetDynamicPstatesInfo)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4796
 *     global __nvmlDeviceGetDynamicPstatesInfo
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDynamicPstatesInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDynamicPstatesInfo is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4799
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDynamicPstatesInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuDynamicPstatesInfo_t*) noexcept nogil>__nvmlDeviceGetDynamicPstatesInfo)(             # <<<<<<<<<<<<<<
 *         device, pDynamicPstatesInfo)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuDynamicPstatesInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDynamicPstatesInfo)(__pyx_v_device, __pyx_v_pDynamicPstatesInfo);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4793
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetDynamicPstatesInfo(nvmlDevice_t device, nvmlGpuDynamicPstatesInfo_t* pDynamicPstatesInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetDynamicPstatesInfo
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetDynamicPstatesInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4803
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMemClkVfOffset(nvmlDevice_t device, int* offset) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMemClkVfOffset
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMemClkVfOffset(nvmlDevice_t __pyx_v_device, int *__pyx_v_offset) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetMemClkVfOffset", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4805
 * cdef nvmlReturn_t _nvmlDeviceGetMemClkVfOffset(nvmlDevice_t device, int* offset) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetMemClkVfOffset
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetMemClkVfOffset == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4805, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4806
 *     global __nvmlDeviceGetMemClkVfOffset
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMemClkVfOffset == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemClkVfOffset is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemClkVfOffset == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4807
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMemClkVfOffset == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemClkVfOffset is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int*) noexcept nogil>__nvmlDeviceGetMemClkVfOffset)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4808
 *     if __nvmlDeviceGetMemClkVfOffset == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemClkVfOffset is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int*) noexcept nogil>__nvmlDeviceGetMemClkVfOffset)(
 *         device, offset)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4808, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetMemClkVfOf};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4808, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4808, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4807
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMemClkVfOffset == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemClkVfOffset is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int*) noexcept nogil>__nvmlDeviceGetMemClkVfOffset)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4806
 *     global __nvmlDeviceGetMemClkVfOffset
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMemClkVfOffset == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemClkVfOffset is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4809
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemClkVfOffset is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int*) noexcept nogil>__nvmlDeviceGetMemClkVfOffset)(             # <<<<<<<<<<<<<<
 *         device, offset)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemClkVfOffset)(__pyx_v_device, __pyx_v_offset);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4803
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMemClkVfOffset(nvmlDevice_t device, int* offset) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMemClkVfOffset
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetMemClkVfOffset", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4813
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMinMaxClockOfPState(nvmlDevice_t device, nvmlClockType_t type, nvmlPstates_t pstate, unsigned int* minClockMHz, unsigned int* maxClockMHz) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMinMaxClockOfPState
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMinMaxClockOfPState(nvmlDevice_t __pyx_v_device, nvmlClockType_t __pyx_v_type, nvmlPstates_t __pyx_v_pstate, unsigned int *__pyx_v_minClockMHz, unsigned int *__pyx_v_maxClockMHz) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetMinMaxClockOfPState", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4815
 * cdef nvmlReturn_t _nvmlDeviceGetMinMaxClockOfPState(nvmlDevice_t device, nvmlClockType_t type, nvmlPstates_t pstate, unsigned int* minClockMHz, unsigned int* maxClockMHz) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetMinMaxClockOfPState
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetMinMaxClockOfPState == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4815, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4816
 *     global __nvmlDeviceGetMinMaxClockOfPState
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMinMaxClockOfPState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMinMaxClockOfPState is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMinMaxClockOfPState == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4817
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMinMaxClockOfPState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMinMaxClockOfPState is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, nvmlPstates_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetMinMaxClockOfPState)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4818
 *     if __nvmlDeviceGetMinMaxClockOfPState == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMinMaxClockOfPState is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, nvmlPstates_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetMinMaxClockOfPState)(
 *         device, type, pstate, minClockMHz, maxClockMHz)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4818, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetMinMaxCloc};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4818, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4818, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4817
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMinMaxClockOfPState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMinMaxClockOfPState is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, nvmlPstates_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetMinMaxClockOfPState)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4816
 *     global __nvmlDeviceGetMinMaxClockOfPState
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMinMaxClockOfPState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMinMaxClockOfPState is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4819
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMinMaxClockOfPState is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, nvmlPstates_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetMinMaxClockOfPState)(             # <<<<<<<<<<<<<<
 *         device, type, pstate, minClockMHz, maxClockMHz)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlClockType_t, nvmlPstates_t, unsigned int *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMinMaxClockOfPState)(__pyx_v_device, __pyx_v_type, __pyx_v_pstate, __pyx_v_minClockMHz, __pyx_v_maxClockMHz);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4813
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMinMaxClockOfPState(nvmlDevice_t device, nvmlClockType_t type, nvmlPstates_t pstate, unsigned int* minClockMHz, unsigned int* maxClockMHz) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMinMaxClockOfPState
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetMinMaxClockOfPState", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4823
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetSupportedPerformanceStates(nvmlDevice_t device, nvmlPstates_t* pstates, unsigned int size) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetSupportedPerformanceStates
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetSupportedPerformanceStates(nvmlDevice_t __pyx_v_device, nvmlPstates_t *__pyx_v_pstates, unsigned int __pyx_v_size) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetSupportedPerformanceStates", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4825
 * cdef nvmlReturn_t _nvmlDeviceGetSupportedPerformanceStates(nvmlDevice_t device, nvmlPstates_t* pstates, unsigned int size) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetSupportedPerformanceStates
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetSupportedPerformanceStates == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4825, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4826
 *     global __nvmlDeviceGetSupportedPerformanceStates
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSupportedPerformanceStates == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedPerformanceStates is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedPerformanceStates == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4827
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSupportedPerformanceStates == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedPerformanceStates is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPstates_t*, unsigned int) noexcept nogil>__nvmlDeviceGetSupportedPerformanceStates)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4828
 *     if __nvmlDeviceGetSupportedPerformanceStates == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedPerformanceStates is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPstates_t*, unsigned int) noexcept nogil>__nvmlDeviceGetSupportedPerformanceStates)(
 *         device, pstates, size)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4828, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetSupportedP};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4828, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4828, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4827
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSupportedPerformanceStates == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedPerformanceStates is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPstates_t*, unsigned int) noexcept nogil>__nvmlDeviceGetSupportedPerformanceStates)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4826
 *     global __nvmlDeviceGetSupportedPerformanceStates
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSupportedPerformanceStates == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedPerformanceStates is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4829
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedPerformanceStates is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPstates_t*, unsigned int) noexcept nogil>__nvmlDeviceGetSupportedPerformanceStates)(             # <<<<<<<<<<<<<<
 *         device, pstates, size)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlPstates_t *, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedPerformanceStates)(__pyx_v_device, __pyx_v_pstates, __pyx_v_size);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4823
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetSupportedPerformanceStates(nvmlDevice_t device, nvmlPstates_t* pstates, unsigned int size) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetSupportedPerformanceStates
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetSupportedPerformanceStates", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4833
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGpcClkMinMaxVfOffset(nvmlDevice_t device, int* minOffset, int* maxOffset) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGpcClkMinMaxVfOffset
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGpcClkMinMaxVfOffset(nvmlDevice_t __pyx_v_device, int *__pyx_v_minOffset, int *__pyx_v_maxOffset) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetGpcClkMinMaxVfOffset", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4835
 * cdef nvmlReturn_t _nvmlDeviceGetGpcClkMinMaxVfOffset(nvmlDevice_t device, int* minOffset, int* maxOffset) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetGpcClkMinMaxVfOffset
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetGpcClkMinMaxVfOffset == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4835, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4836
 *     global __nvmlDeviceGetGpcClkMinMaxVfOffset
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpcClkMinMaxVfOffset == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpcClkMinMaxVfOffset is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpcClkMinMaxVfOffset == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4837
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpcClkMinMaxVfOffset == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpcClkMinMaxVfOffset is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int*, int*) noexcept nogil>__nvmlDeviceGetGpcClkMinMaxVfOffset)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4838
 *     if __nvmlDeviceGetGpcClkMinMaxVfOffset == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpcClkMinMaxVfOffset is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int*, int*) noexcept nogil>__nvmlDeviceGetGpcClkMinMaxVfOffset)(
 *         device, minOffset, maxOffset)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4838, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetGpcClkMinM};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4838, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4838, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4837
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpcClkMinMaxVfOffset == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpcClkMinMaxVfOffset is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int*, int*) noexcept nogil>__nvmlDeviceGetGpcClkMinMaxVfOffset)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4836
 *     global __nvmlDeviceGetGpcClkMinMaxVfOffset
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpcClkMinMaxVfOffset == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpcClkMinMaxVfOffset is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4839
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpcClkMinMaxVfOffset is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int*, int*) noexcept nogil>__nvmlDeviceGetGpcClkMinMaxVfOffset)(             # <<<<<<<<<<<<<<
 *         device, minOffset, maxOffset)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, int *, int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpcClkMinMaxVfOffset)(__pyx_v_device, __pyx_v_minOffset, __pyx_v_maxOffset);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4833
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGpcClkMinMaxVfOffset(nvmlDevice_t device, int* minOffset, int* maxOffset) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGpcClkMinMaxVfOffset
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetGpcClkMinMaxVfOffset", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4843
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMemClkMinMaxVfOffset(nvmlDevice_t device, int* minOffset, int* maxOffset) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMemClkMinMaxVfOffset
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMemClkMinMaxVfOffset(nvmlDevice_t __pyx_v_device, int *__pyx_v_minOffset, int *__pyx_v_maxOffset) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetMemClkMinMaxVfOffset", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4845
 * cdef nvmlReturn_t _nvmlDeviceGetMemClkMinMaxVfOffset(nvmlDevice_t device, int* minOffset, int* maxOffset) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetMemClkMinMaxVfOffset
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetMemClkMinMaxVfOffset == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4845, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4846
 *     global __nvmlDeviceGetMemClkMinMaxVfOffset
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMemClkMinMaxVfOffset == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemClkMinMaxVfOffset is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemClkMinMaxVfOffset == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4847
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMemClkMinMaxVfOffset == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemClkMinMaxVfOffset is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int*, int*) noexcept nogil>__nvmlDeviceGetMemClkMinMaxVfOffset)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4848
 *     if __nvmlDeviceGetMemClkMinMaxVfOffset == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemClkMinMaxVfOffset is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int*, int*) noexcept nogil>__nvmlDeviceGetMemClkMinMaxVfOffset)(
 *         device, minOffset, maxOffset)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4848, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetMemClkMinM};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4848, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4848, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4847
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMemClkMinMaxVfOffset == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemClkMinMaxVfOffset is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int*, int*) noexcept nogil>__nvmlDeviceGetMemClkMinMaxVfOffset)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4846
 *     global __nvmlDeviceGetMemClkMinMaxVfOffset
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMemClkMinMaxVfOffset == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemClkMinMaxVfOffset is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4849
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemClkMinMaxVfOffset is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int*, int*) noexcept nogil>__nvmlDeviceGetMemClkMinMaxVfOffset)(             # <<<<<<<<<<<<<<
 *         device, minOffset, maxOffset)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, int *, int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemClkMinMaxVfOffset)(__pyx_v_device, __pyx_v_minOffset, __pyx_v_maxOffset);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4843
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMemClkMinMaxVfOffset(nvmlDevice_t device, int* minOffset, int* maxOffset) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMemClkMinMaxVfOffset
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetMemClkMinMaxVfOffset", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4853
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetClockOffsets(nvmlDevice_t device, nvmlClockOffset_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetClockOffsets
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetClockOffsets(nvmlDevice_t __pyx_v_device, nvmlClockOffset_t *__pyx_v_info) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetClockOffsets", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4855
 * cdef nvmlReturn_t _nvmlDeviceGetClockOffsets(nvmlDevice_t device, nvmlClockOffset_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetClockOffsets
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetClockOffsets == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4855, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4856
 *     global __nvmlDeviceGetClockOffsets
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetClockOffsets == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetClockOffsets is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClockOffsets == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4857
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetClockOffsets == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetClockOffsets is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockOffset_t*) noexcept nogil>__nvmlDeviceGetClockOffsets)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4858
 *     if __nvmlDeviceGetClockOffsets == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetClockOffsets is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockOffset_t*) noexcept nogil>__nvmlDeviceGetClockOffsets)(
 *         device, info)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4858, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetClockOffse};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4858, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4858, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4857
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetClockOffsets == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetClockOffsets is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockOffset_t*) noexcept nogil>__nvmlDeviceGetClockOffsets)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4856
 *     global __nvmlDeviceGetClockOffsets
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetClockOffsets == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetClockOffsets is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4859
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetClockOffsets is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockOffset_t*) noexcept nogil>__nvmlDeviceGetClockOffsets)(             # <<<<<<<<<<<<<<
 *         device, info)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlClockOffset_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClockOffsets)(__pyx_v_device, __pyx_v_info);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4853
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetClockOffsets(nvmlDevice_t device, nvmlClockOffset_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetClockOffsets
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetClockOffsets", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4863
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetClockOffsets(nvmlDevice_t device, nvmlClockOffset_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetClockOffsets
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetClockOffsets(nvmlDevice_t __pyx_v_device, nvmlClockOffset_t *__pyx_v_info) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetClockOffsets", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4865
 * cdef nvmlReturn_t _nvmlDeviceSetClockOffsets(nvmlDevice_t device, nvmlClockOffset_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetClockOffsets
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetClockOffsets == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4865, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4866
 *     global __nvmlDeviceSetClockOffsets
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetClockOffsets == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetClockOffsets is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetClockOffsets == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4867
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetClockOffsets == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetClockOffsets is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockOffset_t*) noexcept nogil>__nvmlDeviceSetClockOffsets)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4868
 *     if __nvmlDeviceSetClockOffsets == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetClockOffsets is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockOffset_t*) noexcept nogil>__nvmlDeviceSetClockOffsets)(
 *         device, info)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4868, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetClockOffse};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4868, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4868, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4867
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetClockOffsets == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetClockOffsets is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockOffset_t*) noexcept nogil>__nvmlDeviceSetClockOffsets)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4866
 *     global __nvmlDeviceSetClockOffsets
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetClockOffsets == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetClockOffsets is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4869
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetClockOffsets is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClockOffset_t*) noexcept nogil>__nvmlDeviceSetClockOffsets)(             # <<<<<<<<<<<<<<
 *         device, info)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlClockOffset_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetClockOffsets)(__pyx_v_device, __pyx_v_info);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4863
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetClockOffsets(nvmlDevice_t device, nvmlClockOffset_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetClockOffsets
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetClockOffsets", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4873
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPerformanceModes(nvmlDevice_t device, nvmlDevicePerfModes_t* perfModes) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPerformanceModes
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPerformanceModes(nvmlDevice_t __pyx_v_device, nvmlDevicePerfModes_t *__pyx_v_perfModes) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetPerformanceModes", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4875
 * cdef nvmlReturn_t _nvmlDeviceGetPerformanceModes(nvmlDevice_t device, nvmlDevicePerfModes_t* perfModes) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetPerformanceModes
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetPerformanceModes == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4875, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4876
 *     global __nvmlDeviceGetPerformanceModes
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPerformanceModes == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPerformanceModes is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPerformanceModes == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4877
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPerformanceModes == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPerformanceModes is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevicePerfModes_t*) noexcept nogil>__nvmlDeviceGetPerformanceModes)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4878
 *     if __nvmlDeviceGetPerformanceModes == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPerformanceModes is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevicePerfModes_t*) noexcept nogil>__nvmlDeviceGetPerformanceModes)(
 *         device, perfModes)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4878, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetPerformanc_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4878, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4878, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4877
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPerformanceModes == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPerformanceModes is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevicePerfModes_t*) noexcept nogil>__nvmlDeviceGetPerformanceModes)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4876
 *     global __nvmlDeviceGetPerformanceModes
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPerformanceModes == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPerformanceModes is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4879
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPerformanceModes is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevicePerfModes_t*) noexcept nogil>__nvmlDeviceGetPerformanceModes)(             # <<<<<<<<<<<<<<
 *         device, perfModes)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlDevicePerfModes_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPerformanceModes)(__pyx_v_device, __pyx_v_perfModes);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4873
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPerformanceModes(nvmlDevice_t device, nvmlDevicePerfModes_t* perfModes) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPerformanceModes
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetPerformanceModes", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4883
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetCurrentClockFreqs(nvmlDevice_t device, nvmlDeviceCurrentClockFreqs_t* currentClockFreqs) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetCurrentClockFreqs
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetCurrentClockFreqs(nvmlDevice_t __pyx_v_device, nvmlDeviceCurrentClockFreqs_t *__pyx_v_currentClockFreqs) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetCurrentClockFreqs", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4885
 * cdef nvmlReturn_t _nvmlDeviceGetCurrentClockFreqs(nvmlDevice_t device, nvmlDeviceCurrentClockFreqs_t* currentClockFreqs) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetCurrentClockFreqs
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetCurrentClockFreqs == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4885, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4886
 *     global __nvmlDeviceGetCurrentClockFreqs
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCurrentClockFreqs == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCurrentClockFreqs is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrentClockFreqs == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4887
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCurrentClockFreqs == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetCurrentClockFreqs is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceCurrentClockFreqs_t*) noexcept nogil>__nvmlDeviceGetCurrentClockFreqs)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4888
 *     if __nvmlDeviceGetCurrentClockFreqs == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCurrentClockFreqs is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceCurrentClockFreqs_t*) noexcept nogil>__nvmlDeviceGetCurrentClockFreqs)(
 *         device, currentClockFreqs)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4888, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetCurrentClo_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4888, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4888, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4887
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCurrentClockFreqs == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetCurrentClockFreqs is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceCurrentClockFreqs_t*) noexcept nogil>__nvmlDeviceGetCurrentClockFreqs)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4886
 *     global __nvmlDeviceGetCurrentClockFreqs
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCurrentClockFreqs == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCurrentClockFreqs is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4889
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCurrentClockFreqs is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceCurrentClockFreqs_t*) noexcept nogil>__nvmlDeviceGetCurrentClockFreqs)(             # <<<<<<<<<<<<<<
 *         device, currentClockFreqs)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceCurrentClockFreqs_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrentClockFreqs)(__pyx_v_device, __pyx_v_currentClockFreqs);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4883
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetCurrentClockFreqs(nvmlDevice_t device, nvmlDeviceCurrentClockFreqs_t* currentClockFreqs) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetCurrentClockFreqs
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetCurrentClockFreqs", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4893
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPowerManagementLimit(nvmlDevice_t device, unsigned int* limit) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPowerManagementLimit
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPowerManagementLimit(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_limit) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetPowerManagementLimit", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4895
 * cdef nvmlReturn_t _nvmlDeviceGetPowerManagementLimit(nvmlDevice_t device, unsigned int* limit) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetPowerManagementLimit
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetPowerManagementLimit == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4895, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4896
 *     global __nvmlDeviceGetPowerManagementLimit
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerManagementLimit == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerManagementLimit is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerManagementLimit == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4897
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerManagementLimit == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerManagementLimit is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPowerManagementLimit)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4898
 *     if __nvmlDeviceGetPowerManagementLimit == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerManagementLimit is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPowerManagementLimit)(
 *         device, limit)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4898, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetPowerManag};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4898, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4898, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4897
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerManagementLimit == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerManagementLimit is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPowerManagementLimit)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4896
 *     global __nvmlDeviceGetPowerManagementLimit
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerManagementLimit == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerManagementLimit is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4899
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerManagementLimit is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPowerManagementLimit)(             # <<<<<<<<<<<<<<
 *         device, limit)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerManagementLimit)(__pyx_v_device, __pyx_v_limit);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4893
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPowerManagementLimit(nvmlDevice_t device, unsigned int* limit) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPowerManagementLimit
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetPowerManagementLimit", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4903
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPowerManagementLimitConstraints(nvmlDevice_t device, unsigned int* minLimit, unsigned int* maxLimit) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPowerManagementLimitConstraints
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPowerManagementLimitConstraints(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_minLimit, unsigned int *__pyx_v_maxLimit) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetPowerManagementLimitConstraints", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4905
 * cdef nvmlReturn_t _nvmlDeviceGetPowerManagementLimitConstraints(nvmlDevice_t device, unsigned int* minLimit, unsigned int* maxLimit) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetPowerManagementLimitConstraints
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetPowerManagementLimitConstraints == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4905, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4906
 *     global __nvmlDeviceGetPowerManagementLimitConstraints
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerManagementLimitConstraints == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerManagementLimitConstraints is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerManagementLimitConstraints == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4907
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerManagementLimitConstraints == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerManagementLimitConstraints is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetPowerManagementLimitConstraints)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4908
 *     if __nvmlDeviceGetPowerManagementLimitConstraints == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerManagementLimitConstraints is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetPowerManagementLimitConstraints)(
 *         device, minLimit, maxLimit)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4908, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetPowerManag_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4908, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4908, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4907
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerManagementLimitConstraints == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerManagementLimitConstraints is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetPowerManagementLimitConstraints)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4906
 *     global __nvmlDeviceGetPowerManagementLimitConstraints
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerManagementLimitConstraints == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerManagementLimitConstraints is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4909
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerManagementLimitConstraints is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetPowerManagementLimitConstraints)(             # <<<<<<<<<<<<<<
 *         device, minLimit, maxLimit)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerManagementLimitConstraints)(__pyx_v_device, __pyx_v_minLimit, __pyx_v_maxLimit);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4903
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPowerManagementLimitConstraints(nvmlDevice_t device, unsigned int* minLimit, unsigned int* maxLimit) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPowerManagementLimitConstraints
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetPowerManagementLimitConstraints", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4913
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPowerManagementDefaultLimit(nvmlDevice_t device, unsigned int* defaultLimit) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPowerManagementDefaultLimit
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPowerManagementDefaultLimit(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_defaultLimit) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetPowerManagementDefaultLimit", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4915
 * cdef nvmlReturn_t _nvmlDeviceGetPowerManagementDefaultLimit(nvmlDevice_t device, unsigned int* defaultLimit) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetPowerManagementDefaultLimit
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetPowerManagementDefaultLimit == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4915, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4916
 *     global __nvmlDeviceGetPowerManagementDefaultLimit
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerManagementDefaultLimit == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerManagementDefaultLimit is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerManagementDefaultLimit == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4917
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerManagementDefaultLimit == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerManagementDefaultLimit is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPowerManagementDefaultLimit)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4918
 *     if __nvmlDeviceGetPowerManagementDefaultLimit == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerManagementDefaultLimit is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPowerManagementDefaultLimit)(
 *         device, defaultLimit)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4918, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetPowerManag_3};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4918, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4918, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4917
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerManagementDefaultLimit == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerManagementDefaultLimit is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPowerManagementDefaultLimit)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4916
 *     global __nvmlDeviceGetPowerManagementDefaultLimit
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerManagementDefaultLimit == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerManagementDefaultLimit is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4919
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerManagementDefaultLimit is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPowerManagementDefaultLimit)(             # <<<<<<<<<<<<<<
 *         device, defaultLimit)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerManagementDefaultLimit)(__pyx_v_device, __pyx_v_defaultLimit);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4913
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPowerManagementDefaultLimit(nvmlDevice_t device, unsigned int* defaultLimit) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPowerManagementDefaultLimit
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetPowerManagementDefaultLimit", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4923
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPowerUsage(nvmlDevice_t device, unsigned int* power) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPowerUsage
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPowerUsage(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_power) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetPowerUsage", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4925
 * cdef nvmlReturn_t _nvmlDeviceGetPowerUsage(nvmlDevice_t device, unsigned int* power) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetPowerUsage
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetPowerUsage == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4925, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4926
 *     global __nvmlDeviceGetPowerUsage
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerUsage == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerUsage is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerUsage == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4927
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerUsage == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerUsage is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPowerUsage)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4928
 *     if __nvmlDeviceGetPowerUsage == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerUsage is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPowerUsage)(
 *         device, power)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4928, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetPowerUsage};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4928, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4928, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4927
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerUsage == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerUsage is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPowerUsage)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4926
 *     global __nvmlDeviceGetPowerUsage
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerUsage == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerUsage is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4929
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerUsage is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPowerUsage)(             # <<<<<<<<<<<<<<
 *         device, power)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerUsage)(__pyx_v_device, __pyx_v_power);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4923
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPowerUsage(nvmlDevice_t device, unsigned int* power) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPowerUsage
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetPowerUsage", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4933
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetTotalEnergyConsumption(nvmlDevice_t device, unsigned long long* energy) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetTotalEnergyConsumption
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetTotalEnergyConsumption(nvmlDevice_t __pyx_v_device, unsigned PY_LONG_LONG *__pyx_v_energy) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetTotalEnergyConsumption", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4935
 * cdef nvmlReturn_t _nvmlDeviceGetTotalEnergyConsumption(nvmlDevice_t device, unsigned long long* energy) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetTotalEnergyConsumption
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetTotalEnergyConsumption == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4935, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4936
 *     global __nvmlDeviceGetTotalEnergyConsumption
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTotalEnergyConsumption == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTotalEnergyConsumption is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTotalEnergyConsumption == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4937
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTotalEnergyConsumption == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetTotalEnergyConsumption is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetTotalEnergyConsumption)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4938
 *     if __nvmlDeviceGetTotalEnergyConsumption == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTotalEnergyConsumption is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetTotalEnergyConsumption)(
 *         device, energy)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4938, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetTotalEnerg};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4938, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4938, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4937
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTotalEnergyConsumption == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetTotalEnergyConsumption is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetTotalEnergyConsumption)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4936
 *     global __nvmlDeviceGetTotalEnergyConsumption
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTotalEnergyConsumption == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTotalEnergyConsumption is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4939
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTotalEnergyConsumption is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetTotalEnergyConsumption)(             # <<<<<<<<<<<<<<
 *         device, energy)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned PY_LONG_LONG *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTotalEnergyConsumption)(__pyx_v_device, __pyx_v_energy);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4933
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetTotalEnergyConsumption(nvmlDevice_t device, unsigned long long* energy) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetTotalEnergyConsumption
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetTotalEnergyConsumption", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4943
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetEnforcedPowerLimit(nvmlDevice_t device, unsigned int* limit) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetEnforcedPowerLimit
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetEnforcedPowerLimit(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_limit) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetEnforcedPowerLimit", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4945
 * cdef nvmlReturn_t _nvmlDeviceGetEnforcedPowerLimit(nvmlDevice_t device, unsigned int* limit) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetEnforcedPowerLimit
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetEnforcedPowerLimit == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4945, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4946
 *     global __nvmlDeviceGetEnforcedPowerLimit
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetEnforcedPowerLimit == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetEnforcedPowerLimit is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEnforcedPowerLimit == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4947
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetEnforcedPowerLimit == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetEnforcedPowerLimit is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetEnforcedPowerLimit)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4948
 *     if __nvmlDeviceGetEnforcedPowerLimit == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetEnforcedPowerLimit is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetEnforcedPowerLimit)(
 *         device, limit)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4948, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetEnforcedPo};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4948, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4948, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4947
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetEnforcedPowerLimit == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetEnforcedPowerLimit is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetEnforcedPowerLimit)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4946
 *     global __nvmlDeviceGetEnforcedPowerLimit
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetEnforcedPowerLimit == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetEnforcedPowerLimit is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4949
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetEnforcedPowerLimit is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetEnforcedPowerLimit)(             # <<<<<<<<<<<<<<
 *         device, limit)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEnforcedPowerLimit)(__pyx_v_device, __pyx_v_limit);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4943
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetEnforcedPowerLimit(nvmlDevice_t device, unsigned int* limit) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetEnforcedPowerLimit
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetEnforcedPowerLimit", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4953
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGpuOperationMode(nvmlDevice_t device, nvmlGpuOperationMode_t* current, nvmlGpuOperationMode_t* pending) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGpuOperationMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGpuOperationMode(nvmlDevice_t __pyx_v_device, nvmlGpuOperationMode_t *__pyx_v_current, nvmlGpuOperationMode_t *__pyx_v_pending) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetGpuOperationMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4955
 * cdef nvmlReturn_t _nvmlDeviceGetGpuOperationMode(nvmlDevice_t device, nvmlGpuOperationMode_t* current, nvmlGpuOperationMode_t* pending) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetGpuOperationMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetGpuOperationMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4955, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4956
 *     global __nvmlDeviceGetGpuOperationMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuOperationMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuOperationMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuOperationMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4957
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuOperationMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuOperationMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuOperationMode_t*, nvmlGpuOperationMode_t*) noexcept nogil>__nvmlDeviceGetGpuOperationMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4958
 *     if __nvmlDeviceGetGpuOperationMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuOperationMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuOperationMode_t*, nvmlGpuOperationMode_t*) noexcept nogil>__nvmlDeviceGetGpuOperationMode)(
 *         device, current, pending)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4958, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetGpuOperati};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4958, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4958, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4957
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuOperationMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuOperationMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuOperationMode_t*, nvmlGpuOperationMode_t*) noexcept nogil>__nvmlDeviceGetGpuOperationMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4956
 *     global __nvmlDeviceGetGpuOperationMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuOperationMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuOperationMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4959
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuOperationMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuOperationMode_t*, nvmlGpuOperationMode_t*) noexcept nogil>__nvmlDeviceGetGpuOperationMode)(             # <<<<<<<<<<<<<<
 *         device, current, pending)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuOperationMode_t *, nvmlGpuOperationMode_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuOperationMode)(__pyx_v_device, __pyx_v_current, __pyx_v_pending);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4953
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGpuOperationMode(nvmlDevice_t device, nvmlGpuOperationMode_t* current, nvmlGpuOperationMode_t* pending) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGpuOperationMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetGpuOperationMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4963
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMemoryInfo_v2(nvmlDevice_t device, nvmlMemory_v2_t* memory) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMemoryInfo_v2
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMemoryInfo_v2(nvmlDevice_t __pyx_v_device, nvmlMemory_v2_t *__pyx_v_memory) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetMemoryInfo_v2", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4965
 * cdef nvmlReturn_t _nvmlDeviceGetMemoryInfo_v2(nvmlDevice_t device, nvmlMemory_v2_t* memory) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetMemoryInfo_v2
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetMemoryInfo_v2 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4965, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4966
 *     global __nvmlDeviceGetMemoryInfo_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMemoryInfo_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemoryInfo_v2 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryInfo_v2 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4967
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMemoryInfo_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemoryInfo_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlMemory_v2_t*) noexcept nogil>__nvmlDeviceGetMemoryInfo_v2)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4968
 *     if __nvmlDeviceGetMemoryInfo_v2 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemoryInfo_v2 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlMemory_v2_t*) noexcept nogil>__nvmlDeviceGetMemoryInfo_v2)(
 *         device, memory)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4968, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetMemoryInfo};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4968, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4968, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4967
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMemoryInfo_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemoryInfo_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlMemory_v2_t*) noexcept nogil>__nvmlDeviceGetMemoryInfo_v2)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4966
 *     global __nvmlDeviceGetMemoryInfo_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMemoryInfo_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemoryInfo_v2 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4969
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemoryInfo_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlMemory_v2_t*) noexcept nogil>__nvmlDeviceGetMemoryInfo_v2)(             # <<<<<<<<<<<<<<
 *         device, memory)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlMemory_v2_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryInfo_v2)(__pyx_v_device, __pyx_v_memory);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4963
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMemoryInfo_v2(nvmlDevice_t device, nvmlMemory_v2_t* memory) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMemoryInfo_v2
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetMemoryInfo_v2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4973
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetComputeMode(nvmlDevice_t device, nvmlComputeMode_t* mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetComputeMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetComputeMode(nvmlDevice_t __pyx_v_device, nvmlComputeMode_t *__pyx_v_mode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetComputeMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4975
 * cdef nvmlReturn_t _nvmlDeviceGetComputeMode(nvmlDevice_t device, nvmlComputeMode_t* mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetComputeMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetComputeMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4975, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4976
 *     global __nvmlDeviceGetComputeMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetComputeMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetComputeMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetComputeMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4977
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetComputeMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetComputeMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlComputeMode_t*) noexcept nogil>__nvmlDeviceGetComputeMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4978
 *     if __nvmlDeviceGetComputeMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetComputeMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlComputeMode_t*) noexcept nogil>__nvmlDeviceGetComputeMode)(
 *         device, mode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4978, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetComputeMod};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4978, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4978, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4977
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetComputeMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetComputeMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlComputeMode_t*) noexcept nogil>__nvmlDeviceGetComputeMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4976
 *     global __nvmlDeviceGetComputeMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetComputeMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetComputeMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4979
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetComputeMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlComputeMode_t*) noexcept nogil>__nvmlDeviceGetComputeMode)(             # <<<<<<<<<<<<<<
 *         device, mode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlComputeMode_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetComputeMode)(__pyx_v_device, __pyx_v_mode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4973
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetComputeMode(nvmlDevice_t device, nvmlComputeMode_t* mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetComputeMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetComputeMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4983
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetCudaComputeCapability(nvmlDevice_t device, int* major, int* minor) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetCudaComputeCapability
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetCudaComputeCapability(nvmlDevice_t __pyx_v_device, int *__pyx_v_major, int *__pyx_v_minor) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetCudaComputeCapability", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4985
 * cdef nvmlReturn_t _nvmlDeviceGetCudaComputeCapability(nvmlDevice_t device, int* major, int* minor) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetCudaComputeCapability
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetCudaComputeCapability == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4985, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4986
 *     global __nvmlDeviceGetCudaComputeCapability
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCudaComputeCapability == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCudaComputeCapability is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCudaComputeCapability == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4987
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCudaComputeCapability == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetCudaComputeCapability is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int*, int*) noexcept nogil>__nvmlDeviceGetCudaComputeCapability)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4988
 *     if __nvmlDeviceGetCudaComputeCapability == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCudaComputeCapability is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int*, int*) noexcept nogil>__nvmlDeviceGetCudaComputeCapability)(
 *         device, major, minor)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4988, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetCudaComput};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4988, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4988, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4987
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCudaComputeCapability == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetCudaComputeCapability is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int*, int*) noexcept nogil>__nvmlDeviceGetCudaComputeCapability)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4986
 *     global __nvmlDeviceGetCudaComputeCapability
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCudaComputeCapability == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCudaComputeCapability is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4989
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCudaComputeCapability is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int*, int*) noexcept nogil>__nvmlDeviceGetCudaComputeCapability)(             # <<<<<<<<<<<<<<
 *         device, major, minor)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, int *, int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCudaComputeCapability)(__pyx_v_device, __pyx_v_major, __pyx_v_minor);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4983
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetCudaComputeCapability(nvmlDevice_t device, int* major, int* minor) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetCudaComputeCapability
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetCudaComputeCapability", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":4993
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetDramEncryptionMode(nvmlDevice_t device, nvmlDramEncryptionInfo_t* current, nvmlDramEncryptionInfo_t* pending) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetDramEncryptionMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetDramEncryptionMode(nvmlDevice_t __pyx_v_device, nvmlDramEncryptionInfo_t *__pyx_v_current, nvmlDramEncryptionInfo_t *__pyx_v_pending) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetDramEncryptionMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":4995
 * cdef nvmlReturn_t _nvmlDeviceGetDramEncryptionMode(nvmlDevice_t device, nvmlDramEncryptionInfo_t* current, nvmlDramEncryptionInfo_t* pending) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetDramEncryptionMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetDramEncryptionMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 4995, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":4996
 *     global __nvmlDeviceGetDramEncryptionMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDramEncryptionMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDramEncryptionMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDramEncryptionMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":4997
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDramEncryptionMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetDramEncryptionMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDramEncryptionInfo_t*, nvmlDramEncryptionInfo_t*) noexcept nogil>__nvmlDeviceGetDramEncryptionMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":4998
 *     if __nvmlDeviceGetDramEncryptionMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDramEncryptionMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDramEncryptionInfo_t*, nvmlDramEncryptionInfo_t*) noexcept nogil>__nvmlDeviceGetDramEncryptionMode)(
 *         device, current, pending)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4998, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetDramEncryp};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4998, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 4998, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":4997
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDramEncryptionMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetDramEncryptionMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDramEncryptionInfo_t*, nvmlDramEncryptionInfo_t*) noexcept nogil>__nvmlDeviceGetDramEncryptionMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":4996
 *     global __nvmlDeviceGetDramEncryptionMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDramEncryptionMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDramEncryptionMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":4999
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDramEncryptionMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDramEncryptionInfo_t*, nvmlDramEncryptionInfo_t*) noexcept nogil>__nvmlDeviceGetDramEncryptionMode)(             # <<<<<<<<<<<<<<
 *         device, current, pending)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlDramEncryptionInfo_t *, nvmlDramEncryptionInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDramEncryptionMode)(__pyx_v_device, __pyx_v_current, __pyx_v_pending);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":4993
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetDramEncryptionMode(nvmlDevice_t device, nvmlDramEncryptionInfo_t* current, nvmlDramEncryptionInfo_t* pending) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetDramEncryptionMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetDramEncryptionMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5003
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetDramEncryptionMode(nvmlDevice_t device, const nvmlDramEncryptionInfo_t* dramEncryption) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetDramEncryptionMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetDramEncryptionMode(nvmlDevice_t __pyx_v_device, nvmlDramEncryptionInfo_t const *__pyx_v_dramEncryption) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetDramEncryptionMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5005
 * cdef nvmlReturn_t _nvmlDeviceSetDramEncryptionMode(nvmlDevice_t device, const nvmlDramEncryptionInfo_t* dramEncryption) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetDramEncryptionMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetDramEncryptionMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5005, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5006
 *     global __nvmlDeviceSetDramEncryptionMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetDramEncryptionMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetDramEncryptionMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDramEncryptionMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5007
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetDramEncryptionMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetDramEncryptionMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, const nvmlDramEncryptionInfo_t*) noexcept nogil>__nvmlDeviceSetDramEncryptionMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5008
 *     if __nvmlDeviceSetDramEncryptionMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetDramEncryptionMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, const nvmlDramEncryptionInfo_t*) noexcept nogil>__nvmlDeviceSetDramEncryptionMode)(
 *         device, dramEncryption)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5008, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetDramEncryp};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5008, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5008, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5007
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetDramEncryptionMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetDramEncryptionMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, const nvmlDramEncryptionInfo_t*) noexcept nogil>__nvmlDeviceSetDramEncryptionMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5006
 *     global __nvmlDeviceSetDramEncryptionMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetDramEncryptionMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetDramEncryptionMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5009
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetDramEncryptionMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, const nvmlDramEncryptionInfo_t*) noexcept nogil>__nvmlDeviceSetDramEncryptionMode)(             # <<<<<<<<<<<<<<
 *         device, dramEncryption)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlDramEncryptionInfo_t const *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDramEncryptionMode)(__pyx_v_device, __pyx_v_dramEncryption);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5003
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetDramEncryptionMode(nvmlDevice_t device, const nvmlDramEncryptionInfo_t* dramEncryption) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetDramEncryptionMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetDramEncryptionMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5013
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetEccMode(nvmlDevice_t device, nvmlEnableState_t* current, nvmlEnableState_t* pending) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetEccMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetEccMode(nvmlDevice_t __pyx_v_device, nvmlEnableState_t *__pyx_v_current, nvmlEnableState_t *__pyx_v_pending) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetEccMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5015
 * cdef nvmlReturn_t _nvmlDeviceGetEccMode(nvmlDevice_t device, nvmlEnableState_t* current, nvmlEnableState_t* pending) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetEccMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetEccMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5015, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5016
 *     global __nvmlDeviceGetEccMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetEccMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetEccMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEccMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5017
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetEccMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetEccMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetEccMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5018
 *     if __nvmlDeviceGetEccMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetEccMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetEccMode)(
 *         device, current, pending)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5018, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetEccMode_is};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5018, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5018, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5017
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetEccMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetEccMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetEccMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5016
 *     global __nvmlDeviceGetEccMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetEccMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetEccMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5019
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetEccMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetEccMode)(             # <<<<<<<<<<<<<<
 *         device, current, pending)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t *, nvmlEnableState_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEccMode)(__pyx_v_device, __pyx_v_current, __pyx_v_pending);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5013
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetEccMode(nvmlDevice_t device, nvmlEnableState_t* current, nvmlEnableState_t* pending) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetEccMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetEccMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5023
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetDefaultEccMode(nvmlDevice_t device, nvmlEnableState_t* defaultMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetDefaultEccMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetDefaultEccMode(nvmlDevice_t __pyx_v_device, nvmlEnableState_t *__pyx_v_defaultMode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetDefaultEccMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5025
 * cdef nvmlReturn_t _nvmlDeviceGetDefaultEccMode(nvmlDevice_t device, nvmlEnableState_t* defaultMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetDefaultEccMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetDefaultEccMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5025, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5026
 *     global __nvmlDeviceGetDefaultEccMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDefaultEccMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDefaultEccMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDefaultEccMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5027
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDefaultEccMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetDefaultEccMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetDefaultEccMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5028
 *     if __nvmlDeviceGetDefaultEccMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDefaultEccMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetDefaultEccMode)(
 *         device, defaultMode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5028, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetDefaultEcc};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5028, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5028, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5027
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDefaultEccMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetDefaultEccMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetDefaultEccMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5026
 *     global __nvmlDeviceGetDefaultEccMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDefaultEccMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDefaultEccMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5029
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDefaultEccMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetDefaultEccMode)(             # <<<<<<<<<<<<<<
 *         device, defaultMode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDefaultEccMode)(__pyx_v_device, __pyx_v_defaultMode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5023
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetDefaultEccMode(nvmlDevice_t device, nvmlEnableState_t* defaultMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetDefaultEccMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetDefaultEccMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5033
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetBoardId(nvmlDevice_t device, unsigned int* boardId) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetBoardId
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetBoardId(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_boardId) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetBoardId", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5035
 * cdef nvmlReturn_t _nvmlDeviceGetBoardId(nvmlDevice_t device, unsigned int* boardId) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetBoardId
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetBoardId == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5035, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5036
 *     global __nvmlDeviceGetBoardId
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetBoardId == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetBoardId is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBoardId == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5037
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetBoardId == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetBoardId is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetBoardId)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5038
 *     if __nvmlDeviceGetBoardId == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetBoardId is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetBoardId)(
 *         device, boardId)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5038, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetBoardId_is};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5038, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5038, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5037
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetBoardId == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetBoardId is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetBoardId)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5036
 *     global __nvmlDeviceGetBoardId
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetBoardId == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetBoardId is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5039
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetBoardId is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetBoardId)(             # <<<<<<<<<<<<<<
 *         device, boardId)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBoardId)(__pyx_v_device, __pyx_v_boardId);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5033
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetBoardId(nvmlDevice_t device, unsigned int* boardId) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetBoardId
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetBoardId", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5043
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMultiGpuBoard(nvmlDevice_t device, unsigned int* multiGpuBool) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMultiGpuBoard
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMultiGpuBoard(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_multiGpuBool) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetMultiGpuBoard", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5045
 * cdef nvmlReturn_t _nvmlDeviceGetMultiGpuBoard(nvmlDevice_t device, unsigned int* multiGpuBool) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetMultiGpuBoard
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetMultiGpuBoard == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5045, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5046
 *     global __nvmlDeviceGetMultiGpuBoard
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMultiGpuBoard == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMultiGpuBoard is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMultiGpuBoard == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5047
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMultiGpuBoard == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMultiGpuBoard is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMultiGpuBoard)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5048
 *     if __nvmlDeviceGetMultiGpuBoard == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMultiGpuBoard is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMultiGpuBoard)(
 *         device, multiGpuBool)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5048, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetMultiGpuBo};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5048, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5048, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5047
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMultiGpuBoard == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMultiGpuBoard is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMultiGpuBoard)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5046
 *     global __nvmlDeviceGetMultiGpuBoard
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMultiGpuBoard == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMultiGpuBoard is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5049
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMultiGpuBoard is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMultiGpuBoard)(             # <<<<<<<<<<<<<<
 *         device, multiGpuBool)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMultiGpuBoard)(__pyx_v_device, __pyx_v_multiGpuBool);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5043
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMultiGpuBoard(nvmlDevice_t device, unsigned int* multiGpuBool) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMultiGpuBoard
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetMultiGpuBoard", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5053
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetTotalEccErrors(nvmlDevice_t device, nvmlMemoryErrorType_t errorType, nvmlEccCounterType_t counterType, unsigned long long* eccCounts) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetTotalEccErrors
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetTotalEccErrors(nvmlDevice_t __pyx_v_device, nvmlMemoryErrorType_t __pyx_v_errorType, nvmlEccCounterType_t __pyx_v_counterType, unsigned PY_LONG_LONG *__pyx_v_eccCounts) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetTotalEccErrors", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5055
 * cdef nvmlReturn_t _nvmlDeviceGetTotalEccErrors(nvmlDevice_t device, nvmlMemoryErrorType_t errorType, nvmlEccCounterType_t counterType, unsigned long long* eccCounts) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetTotalEccErrors
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetTotalEccErrors == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5055, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5056
 *     global __nvmlDeviceGetTotalEccErrors
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTotalEccErrors == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTotalEccErrors is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTotalEccErrors == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5057
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTotalEccErrors == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetTotalEccErrors is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlMemoryErrorType_t, nvmlEccCounterType_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetTotalEccErrors)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5058
 *     if __nvmlDeviceGetTotalEccErrors == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTotalEccErrors is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlMemoryErrorType_t, nvmlEccCounterType_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetTotalEccErrors)(
 *         device, errorType, counterType, eccCounts)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5058, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetTotalEccEr};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5058, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5058, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5057
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTotalEccErrors == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetTotalEccErrors is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlMemoryErrorType_t, nvmlEccCounterType_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetTotalEccErrors)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5056
 *     global __nvmlDeviceGetTotalEccErrors
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetTotalEccErrors == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTotalEccErrors is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5059
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetTotalEccErrors is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlMemoryErrorType_t, nvmlEccCounterType_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetTotalEccErrors)(             # <<<<<<<<<<<<<<
 *         device, errorType, counterType, eccCounts)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlMemoryErrorType_t, nvmlEccCounterType_t, unsigned PY_LONG_LONG *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTotalEccErrors)(__pyx_v_device, __pyx_v_errorType, __pyx_v_counterType, __pyx_v_eccCounts);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5053
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetTotalEccErrors(nvmlDevice_t device, nvmlMemoryErrorType_t errorType, nvmlEccCounterType_t counterType, unsigned long long* eccCounts) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetTotalEccErrors
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetTotalEccErrors", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5063
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMemoryErrorCounter(nvmlDevice_t device, nvmlMemoryErrorType_t errorType, nvmlEccCounterType_t counterType, nvmlMemoryLocation_t locationType, unsigned long long* count) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMemoryErrorCounter
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMemoryErrorCounter(nvmlDevice_t __pyx_v_device, nvmlMemoryErrorType_t __pyx_v_errorType, nvmlEccCounterType_t __pyx_v_counterType, nvmlMemoryLocation_t __pyx_v_locationType, unsigned PY_LONG_LONG *__pyx_v_count) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetMemoryErrorCounter", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5065
 * cdef nvmlReturn_t _nvmlDeviceGetMemoryErrorCounter(nvmlDevice_t device, nvmlMemoryErrorType_t errorType, nvmlEccCounterType_t counterType, nvmlMemoryLocation_t locationType, unsigned long long* count) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetMemoryErrorCounter
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetMemoryErrorCounter == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5065, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5066
 *     global __nvmlDeviceGetMemoryErrorCounter
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMemoryErrorCounter == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemoryErrorCounter is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryErrorCounter == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5067
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMemoryErrorCounter == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemoryErrorCounter is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlMemoryErrorType_t, nvmlEccCounterType_t, nvmlMemoryLocation_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetMemoryErrorCounter)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5068
 *     if __nvmlDeviceGetMemoryErrorCounter == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemoryErrorCounter is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlMemoryErrorType_t, nvmlEccCounterType_t, nvmlMemoryLocation_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetMemoryErrorCounter)(
 *         device, errorType, counterType, locationType, count)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5068, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetMemoryErro};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5068, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5068, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5067
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMemoryErrorCounter == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemoryErrorCounter is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlMemoryErrorType_t, nvmlEccCounterType_t, nvmlMemoryLocation_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetMemoryErrorCounter)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5066
 *     global __nvmlDeviceGetMemoryErrorCounter
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMemoryErrorCounter == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemoryErrorCounter is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5069
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemoryErrorCounter is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlMemoryErrorType_t, nvmlEccCounterType_t, nvmlMemoryLocation_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetMemoryErrorCounter)(             # <<<<<<<<<<<<<<
 *         device, errorType, counterType, locationType, count)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlMemoryErrorType_t, nvmlEccCounterType_t, nvmlMemoryLocation_t, unsigned PY_LONG_LONG *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryErrorCounter)(__pyx_v_device, __pyx_v_errorType, __pyx_v_counterType, __pyx_v_locationType, __pyx_v_count);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5063
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMemoryErrorCounter(nvmlDevice_t device, nvmlMemoryErrorType_t errorType, nvmlEccCounterType_t counterType, nvmlMemoryLocation_t locationType, unsigned long long* count) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMemoryErrorCounter
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetMemoryErrorCounter", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5073
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetUtilizationRates(nvmlDevice_t device, nvmlUtilization_t* utilization) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetUtilizationRates
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetUtilizationRates(nvmlDevice_t __pyx_v_device, nvmlUtilization_t *__pyx_v_utilization) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetUtilizationRates", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5075
 * cdef nvmlReturn_t _nvmlDeviceGetUtilizationRates(nvmlDevice_t device, nvmlUtilization_t* utilization) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetUtilizationRates
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetUtilizationRates == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5075, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5076
 *     global __nvmlDeviceGetUtilizationRates
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetUtilizationRates == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetUtilizationRates is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetUtilizationRates == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5077
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetUtilizationRates == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetUtilizationRates is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlUtilization_t*) noexcept nogil>__nvmlDeviceGetUtilizationRates)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5078
 *     if __nvmlDeviceGetUtilizationRates == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetUtilizationRates is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlUtilization_t*) noexcept nogil>__nvmlDeviceGetUtilizationRates)(
 *         device, utilization)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5078, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetUtilizatio};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5078, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5078, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5077
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetUtilizationRates == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetUtilizationRates is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlUtilization_t*) noexcept nogil>__nvmlDeviceGetUtilizationRates)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5076
 *     global __nvmlDeviceGetUtilizationRates
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetUtilizationRates == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetUtilizationRates is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5079
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetUtilizationRates is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlUtilization_t*) noexcept nogil>__nvmlDeviceGetUtilizationRates)(             # <<<<<<<<<<<<<<
 *         device, utilization)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlUtilization_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetUtilizationRates)(__pyx_v_device, __pyx_v_utilization);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5073
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetUtilizationRates(nvmlDevice_t device, nvmlUtilization_t* utilization) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetUtilizationRates
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetUtilizationRates", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5083
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetEncoderUtilization(nvmlDevice_t device, unsigned int* utilization, unsigned int* samplingPeriodUs) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetEncoderUtilization
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetEncoderUtilization(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_utilization, unsigned int *__pyx_v_samplingPeriodUs) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetEncoderUtilization", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5085
 * cdef nvmlReturn_t _nvmlDeviceGetEncoderUtilization(nvmlDevice_t device, unsigned int* utilization, unsigned int* samplingPeriodUs) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetEncoderUtilization
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetEncoderUtilization == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5085, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5086
 *     global __nvmlDeviceGetEncoderUtilization
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetEncoderUtilization == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetEncoderUtilization is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderUtilization == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5087
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetEncoderUtilization == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetEncoderUtilization is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetEncoderUtilization)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5088
 *     if __nvmlDeviceGetEncoderUtilization == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetEncoderUtilization is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetEncoderUtilization)(
 *         device, utilization, samplingPeriodUs)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5088, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetEncoderUti};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5088, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5088, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5087
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetEncoderUtilization == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetEncoderUtilization is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetEncoderUtilization)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5086
 *     global __nvmlDeviceGetEncoderUtilization
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetEncoderUtilization == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetEncoderUtilization is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5089
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetEncoderUtilization is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetEncoderUtilization)(             # <<<<<<<<<<<<<<
 *         device, utilization, samplingPeriodUs)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderUtilization)(__pyx_v_device, __pyx_v_utilization, __pyx_v_samplingPeriodUs);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5083
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetEncoderUtilization(nvmlDevice_t device, unsigned int* utilization, unsigned int* samplingPeriodUs) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetEncoderUtilization
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetEncoderUtilization", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5093
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetEncoderCapacity(nvmlDevice_t device, nvmlEncoderType_t encoderQueryType, unsigned int* encoderCapacity) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetEncoderCapacity
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetEncoderCapacity(nvmlDevice_t __pyx_v_device, nvmlEncoderType_t __pyx_v_encoderQueryType, unsigned int *__pyx_v_encoderCapacity) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetEncoderCapacity", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5095
 * cdef nvmlReturn_t _nvmlDeviceGetEncoderCapacity(nvmlDevice_t device, nvmlEncoderType_t encoderQueryType, unsigned int* encoderCapacity) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetEncoderCapacity
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetEncoderCapacity == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5095, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5096
 *     global __nvmlDeviceGetEncoderCapacity
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetEncoderCapacity == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetEncoderCapacity is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderCapacity == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5097
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetEncoderCapacity == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetEncoderCapacity is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEncoderType_t, unsigned int*) noexcept nogil>__nvmlDeviceGetEncoderCapacity)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5098
 *     if __nvmlDeviceGetEncoderCapacity == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetEncoderCapacity is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEncoderType_t, unsigned int*) noexcept nogil>__nvmlDeviceGetEncoderCapacity)(
 *         device, encoderQueryType, encoderCapacity)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5098, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetEncoderCap};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5098, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5098, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5097
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetEncoderCapacity == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetEncoderCapacity is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEncoderType_t, unsigned int*) noexcept nogil>__nvmlDeviceGetEncoderCapacity)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5096
 *     global __nvmlDeviceGetEncoderCapacity
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetEncoderCapacity == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetEncoderCapacity is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5099
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetEncoderCapacity is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEncoderType_t, unsigned int*) noexcept nogil>__nvmlDeviceGetEncoderCapacity)(             # <<<<<<<<<<<<<<
 *         device, encoderQueryType, encoderCapacity)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlEncoderType_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderCapacity)(__pyx_v_device, __pyx_v_encoderQueryType, __pyx_v_encoderCapacity);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5093
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetEncoderCapacity(nvmlDevice_t device, nvmlEncoderType_t encoderQueryType, unsigned int* encoderCapacity) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetEncoderCapacity
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetEncoderCapacity", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5103
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetEncoderStats(nvmlDevice_t device, unsigned int* sessionCount, unsigned int* averageFps, unsigned int* averageLatency) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetEncoderStats
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetEncoderStats(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_sessionCount, unsigned int *__pyx_v_averageFps, unsigned int *__pyx_v_averageLatency) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetEncoderStats", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5105
 * cdef nvmlReturn_t _nvmlDeviceGetEncoderStats(nvmlDevice_t device, unsigned int* sessionCount, unsigned int* averageFps, unsigned int* averageLatency) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetEncoderStats
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetEncoderStats == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5105, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5106
 *     global __nvmlDeviceGetEncoderStats
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetEncoderStats == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetEncoderStats is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderStats == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5107
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetEncoderStats == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetEncoderStats is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetEncoderStats)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5108
 *     if __nvmlDeviceGetEncoderStats == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetEncoderStats is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetEncoderStats)(
 *         device, sessionCount, averageFps, averageLatency)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5108, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetEncoderSta};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5108, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5108, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5107
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetEncoderStats == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetEncoderStats is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetEncoderStats)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5106
 *     global __nvmlDeviceGetEncoderStats
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetEncoderStats == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetEncoderStats is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5109
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetEncoderStats is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetEncoderStats)(             # <<<<<<<<<<<<<<
 *         device, sessionCount, averageFps, averageLatency)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *, unsigned int *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderStats)(__pyx_v_device, __pyx_v_sessionCount, __pyx_v_averageFps, __pyx_v_averageLatency);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5103
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetEncoderStats(nvmlDevice_t device, unsigned int* sessionCount, unsigned int* averageFps, unsigned int* averageLatency) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetEncoderStats
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetEncoderStats", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5113
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetEncoderSessions(nvmlDevice_t device, unsigned int* sessionCount, nvmlEncoderSessionInfo_t* sessionInfos) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetEncoderSessions
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetEncoderSessions(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_sessionCount, nvmlEncoderSessionInfo_t *__pyx_v_sessionInfos) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetEncoderSessions", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5115
 * cdef nvmlReturn_t _nvmlDeviceGetEncoderSessions(nvmlDevice_t device, unsigned int* sessionCount, nvmlEncoderSessionInfo_t* sessionInfos) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetEncoderSessions
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetEncoderSessions == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5115, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5116
 *     global __nvmlDeviceGetEncoderSessions
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetEncoderSessions == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetEncoderSessions is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderSessions == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5117
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetEncoderSessions == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetEncoderSessions is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlEncoderSessionInfo_t*) noexcept nogil>__nvmlDeviceGetEncoderSessions)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5118
 *     if __nvmlDeviceGetEncoderSessions == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetEncoderSessions is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlEncoderSessionInfo_t*) noexcept nogil>__nvmlDeviceGetEncoderSessions)(
 *         device, sessionCount, sessionInfos)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5118, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetEncoderSes};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5118, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5118, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5117
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetEncoderSessions == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetEncoderSessions is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlEncoderSessionInfo_t*) noexcept nogil>__nvmlDeviceGetEncoderSessions)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5116
 *     global __nvmlDeviceGetEncoderSessions
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetEncoderSessions == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetEncoderSessions is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5119
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetEncoderSessions is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlEncoderSessionInfo_t*) noexcept nogil>__nvmlDeviceGetEncoderSessions)(             # <<<<<<<<<<<<<<
 *         device, sessionCount, sessionInfos)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *, nvmlEncoderSessionInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderSessions)(__pyx_v_device, __pyx_v_sessionCount, __pyx_v_sessionInfos);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5113
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetEncoderSessions(nvmlDevice_t device, unsigned int* sessionCount, nvmlEncoderSessionInfo_t* sessionInfos) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetEncoderSessions
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetEncoderSessions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5123
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetDecoderUtilization(nvmlDevice_t device, unsigned int* utilization, unsigned int* samplingPeriodUs) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetDecoderUtilization
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetDecoderUtilization(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_utilization, unsigned int *__pyx_v_samplingPeriodUs) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetDecoderUtilization", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5125
 * cdef nvmlReturn_t _nvmlDeviceGetDecoderUtilization(nvmlDevice_t device, unsigned int* utilization, unsigned int* samplingPeriodUs) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetDecoderUtilization
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetDecoderUtilization == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5125, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5126
 *     global __nvmlDeviceGetDecoderUtilization
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDecoderUtilization == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDecoderUtilization is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDecoderUtilization == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5127
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDecoderUtilization == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetDecoderUtilization is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetDecoderUtilization)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5128
 *     if __nvmlDeviceGetDecoderUtilization == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDecoderUtilization is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetDecoderUtilization)(
 *         device, utilization, samplingPeriodUs)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5128, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetDecoderUti};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5128, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5128, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5127
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDecoderUtilization == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetDecoderUtilization is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetDecoderUtilization)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5126
 *     global __nvmlDeviceGetDecoderUtilization
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDecoderUtilization == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDecoderUtilization is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5129
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDecoderUtilization is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetDecoderUtilization)(             # <<<<<<<<<<<<<<
 *         device, utilization, samplingPeriodUs)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDecoderUtilization)(__pyx_v_device, __pyx_v_utilization, __pyx_v_samplingPeriodUs);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5123
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetDecoderUtilization(nvmlDevice_t device, unsigned int* utilization, unsigned int* samplingPeriodUs) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetDecoderUtilization
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetDecoderUtilization", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5133
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetJpgUtilization(nvmlDevice_t device, unsigned int* utilization, unsigned int* samplingPeriodUs) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetJpgUtilization
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetJpgUtilization(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_utilization, unsigned int *__pyx_v_samplingPeriodUs) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetJpgUtilization", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5135
 * cdef nvmlReturn_t _nvmlDeviceGetJpgUtilization(nvmlDevice_t device, unsigned int* utilization, unsigned int* samplingPeriodUs) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetJpgUtilization
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetJpgUtilization == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5135, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5136
 *     global __nvmlDeviceGetJpgUtilization
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetJpgUtilization == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetJpgUtilization is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetJpgUtilization == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5137
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetJpgUtilization == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetJpgUtilization is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetJpgUtilization)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5138
 *     if __nvmlDeviceGetJpgUtilization == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetJpgUtilization is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetJpgUtilization)(
 *         device, utilization, samplingPeriodUs)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5138, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetJpgUtiliza};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5138, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5138, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5137
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetJpgUtilization == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetJpgUtilization is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetJpgUtilization)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5136
 *     global __nvmlDeviceGetJpgUtilization
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetJpgUtilization == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetJpgUtilization is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5139
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetJpgUtilization is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetJpgUtilization)(             # <<<<<<<<<<<<<<
 *         device, utilization, samplingPeriodUs)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetJpgUtilization)(__pyx_v_device, __pyx_v_utilization, __pyx_v_samplingPeriodUs);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5133
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetJpgUtilization(nvmlDevice_t device, unsigned int* utilization, unsigned int* samplingPeriodUs) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetJpgUtilization
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetJpgUtilization", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5143
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetOfaUtilization(nvmlDevice_t device, unsigned int* utilization, unsigned int* samplingPeriodUs) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetOfaUtilization
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetOfaUtilization(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_utilization, unsigned int *__pyx_v_samplingPeriodUs) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetOfaUtilization", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5145
 * cdef nvmlReturn_t _nvmlDeviceGetOfaUtilization(nvmlDevice_t device, unsigned int* utilization, unsigned int* samplingPeriodUs) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetOfaUtilization
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetOfaUtilization == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5145, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5146
 *     global __nvmlDeviceGetOfaUtilization
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetOfaUtilization == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetOfaUtilization is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetOfaUtilization == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5147
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetOfaUtilization == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetOfaUtilization is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetOfaUtilization)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5148
 *     if __nvmlDeviceGetOfaUtilization == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetOfaUtilization is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetOfaUtilization)(
 *         device, utilization, samplingPeriodUs)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5148, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetOfaUtiliza};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5148, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5148, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5147
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetOfaUtilization == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetOfaUtilization is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetOfaUtilization)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5146
 *     global __nvmlDeviceGetOfaUtilization
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetOfaUtilization == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetOfaUtilization is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5149
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetOfaUtilization is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetOfaUtilization)(             # <<<<<<<<<<<<<<
 *         device, utilization, samplingPeriodUs)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetOfaUtilization)(__pyx_v_device, __pyx_v_utilization, __pyx_v_samplingPeriodUs);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5143
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetOfaUtilization(nvmlDevice_t device, unsigned int* utilization, unsigned int* samplingPeriodUs) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetOfaUtilization
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetOfaUtilization", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5153
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetFBCStats(nvmlDevice_t device, nvmlFBCStats_t* fbcStats) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetFBCStats
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetFBCStats(nvmlDevice_t __pyx_v_device, nvmlFBCStats_t *__pyx_v_fbcStats) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetFBCStats", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5155
 * cdef nvmlReturn_t _nvmlDeviceGetFBCStats(nvmlDevice_t device, nvmlFBCStats_t* fbcStats) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetFBCStats
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetFBCStats == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5155, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5156
 *     global __nvmlDeviceGetFBCStats
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFBCStats == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFBCStats is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFBCStats == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5157
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFBCStats == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetFBCStats is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlFBCStats_t*) noexcept nogil>__nvmlDeviceGetFBCStats)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5158
 *     if __nvmlDeviceGetFBCStats == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFBCStats is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlFBCStats_t*) noexcept nogil>__nvmlDeviceGetFBCStats)(
 *         device, fbcStats)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5158, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetFBCStats_i};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5158, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5158, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5157
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFBCStats == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetFBCStats is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlFBCStats_t*) noexcept nogil>__nvmlDeviceGetFBCStats)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5156
 *     global __nvmlDeviceGetFBCStats
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFBCStats == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFBCStats is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5159
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFBCStats is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlFBCStats_t*) noexcept nogil>__nvmlDeviceGetFBCStats)(             # <<<<<<<<<<<<<<
 *         device, fbcStats)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlFBCStats_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFBCStats)(__pyx_v_device, __pyx_v_fbcStats);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5153
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetFBCStats(nvmlDevice_t device, nvmlFBCStats_t* fbcStats) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetFBCStats
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetFBCStats", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5163
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetFBCSessions(nvmlDevice_t device, unsigned int* sessionCount, nvmlFBCSessionInfo_t* sessionInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetFBCSessions
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetFBCSessions(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_sessionCount, nvmlFBCSessionInfo_t *__pyx_v_sessionInfo) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetFBCSessions", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5165
 * cdef nvmlReturn_t _nvmlDeviceGetFBCSessions(nvmlDevice_t device, unsigned int* sessionCount, nvmlFBCSessionInfo_t* sessionInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetFBCSessions
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetFBCSessions == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5165, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5166
 *     global __nvmlDeviceGetFBCSessions
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFBCSessions == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFBCSessions is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFBCSessions == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5167
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFBCSessions == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetFBCSessions is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlFBCSessionInfo_t*) noexcept nogil>__nvmlDeviceGetFBCSessions)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5168
 *     if __nvmlDeviceGetFBCSessions == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFBCSessions is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlFBCSessionInfo_t*) noexcept nogil>__nvmlDeviceGetFBCSessions)(
 *         device, sessionCount, sessionInfo)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5168, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetFBCSession};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5168, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5168, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5167
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFBCSessions == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetFBCSessions is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlFBCSessionInfo_t*) noexcept nogil>__nvmlDeviceGetFBCSessions)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5166
 *     global __nvmlDeviceGetFBCSessions
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFBCSessions == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFBCSessions is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5169
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFBCSessions is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlFBCSessionInfo_t*) noexcept nogil>__nvmlDeviceGetFBCSessions)(             # <<<<<<<<<<<<<<
 *         device, sessionCount, sessionInfo)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *, nvmlFBCSessionInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFBCSessions)(__pyx_v_device, __pyx_v_sessionCount, __pyx_v_sessionInfo);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5163
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetFBCSessions(nvmlDevice_t device, unsigned int* sessionCount, nvmlFBCSessionInfo_t* sessionInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetFBCSessions
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetFBCSessions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5173
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetDriverModel_v2(nvmlDevice_t device, nvmlDriverModel_t* current, nvmlDriverModel_t* pending) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetDriverModel_v2
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetDriverModel_v2(nvmlDevice_t __pyx_v_device, nvmlDriverModel_t *__pyx_v_current, nvmlDriverModel_t *__pyx_v_pending) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetDriverModel_v2", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5175
 * cdef nvmlReturn_t _nvmlDeviceGetDriverModel_v2(nvmlDevice_t device, nvmlDriverModel_t* current, nvmlDriverModel_t* pending) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetDriverModel_v2
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetDriverModel_v2 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5175, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5176
 *     global __nvmlDeviceGetDriverModel_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDriverModel_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDriverModel_v2 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDriverModel_v2 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5177
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDriverModel_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetDriverModel_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDriverModel_t*, nvmlDriverModel_t*) noexcept nogil>__nvmlDeviceGetDriverModel_v2)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5178
 *     if __nvmlDeviceGetDriverModel_v2 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDriverModel_v2 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDriverModel_t*, nvmlDriverModel_t*) noexcept nogil>__nvmlDeviceGetDriverModel_v2)(
 *         device, current, pending)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5178, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetDriverMode};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5178, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5178, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5177
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDriverModel_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetDriverModel_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDriverModel_t*, nvmlDriverModel_t*) noexcept nogil>__nvmlDeviceGetDriverModel_v2)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5176
 *     global __nvmlDeviceGetDriverModel_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDriverModel_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDriverModel_v2 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5179
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDriverModel_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDriverModel_t*, nvmlDriverModel_t*) noexcept nogil>__nvmlDeviceGetDriverModel_v2)(             # <<<<<<<<<<<<<<
 *         device, current, pending)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlDriverModel_t *, nvmlDriverModel_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDriverModel_v2)(__pyx_v_device, __pyx_v_current, __pyx_v_pending);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5173
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetDriverModel_v2(nvmlDevice_t device, nvmlDriverModel_t* current, nvmlDriverModel_t* pending) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetDriverModel_v2
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetDriverModel_v2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5183
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVbiosVersion(nvmlDevice_t device, char* version, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVbiosVersion
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVbiosVersion(nvmlDevice_t __pyx_v_device, char *__pyx_v_version, unsigned int __pyx_v_length) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetVbiosVersion", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5185
 * cdef nvmlReturn_t _nvmlDeviceGetVbiosVersion(nvmlDevice_t device, char* version, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetVbiosVersion
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetVbiosVersion == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5185, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5186
 *     global __nvmlDeviceGetVbiosVersion
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVbiosVersion == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVbiosVersion is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVbiosVersion == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5187
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVbiosVersion == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVbiosVersion is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetVbiosVersion)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5188
 *     if __nvmlDeviceGetVbiosVersion == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVbiosVersion is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetVbiosVersion)(
 *         device, version, length)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5188, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetVbiosVersi};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5188, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5188, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5187
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVbiosVersion == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVbiosVersion is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetVbiosVersion)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5186
 *     global __nvmlDeviceGetVbiosVersion
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVbiosVersion == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVbiosVersion is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5189
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVbiosVersion is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int) noexcept nogil>__nvmlDeviceGetVbiosVersion)(             # <<<<<<<<<<<<<<
 *         device, version, length)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, char *, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVbiosVersion)(__pyx_v_device, __pyx_v_version, __pyx_v_length);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5183
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVbiosVersion(nvmlDevice_t device, char* version, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVbiosVersion
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetVbiosVersion", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5193
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetBridgeChipInfo(nvmlDevice_t device, nvmlBridgeChipHierarchy_t* bridgeHierarchy) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetBridgeChipInfo
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetBridgeChipInfo(nvmlDevice_t __pyx_v_device, nvmlBridgeChipHierarchy_t *__pyx_v_bridgeHierarchy) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetBridgeChipInfo", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5195
 * cdef nvmlReturn_t _nvmlDeviceGetBridgeChipInfo(nvmlDevice_t device, nvmlBridgeChipHierarchy_t* bridgeHierarchy) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetBridgeChipInfo
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetBridgeChipInfo == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5195, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5196
 *     global __nvmlDeviceGetBridgeChipInfo
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetBridgeChipInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetBridgeChipInfo is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBridgeChipInfo == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5197
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetBridgeChipInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetBridgeChipInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlBridgeChipHierarchy_t*) noexcept nogil>__nvmlDeviceGetBridgeChipInfo)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5198
 *     if __nvmlDeviceGetBridgeChipInfo == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetBridgeChipInfo is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlBridgeChipHierarchy_t*) noexcept nogil>__nvmlDeviceGetBridgeChipInfo)(
 *         device, bridgeHierarchy)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5198, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetBridgeChip};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5198, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5198, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5197
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetBridgeChipInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetBridgeChipInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlBridgeChipHierarchy_t*) noexcept nogil>__nvmlDeviceGetBridgeChipInfo)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5196
 *     global __nvmlDeviceGetBridgeChipInfo
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetBridgeChipInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetBridgeChipInfo is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5199
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetBridgeChipInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlBridgeChipHierarchy_t*) noexcept nogil>__nvmlDeviceGetBridgeChipInfo)(             # <<<<<<<<<<<<<<
 *         device, bridgeHierarchy)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlBridgeChipHierarchy_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBridgeChipInfo)(__pyx_v_device, __pyx_v_bridgeHierarchy);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5193
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetBridgeChipInfo(nvmlDevice_t device, nvmlBridgeChipHierarchy_t* bridgeHierarchy) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetBridgeChipInfo
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetBridgeChipInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5203
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetComputeRunningProcesses_v3(nvmlDevice_t device, unsigned int* infoCount, nvmlProcessInfo_t* infos) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetComputeRunningProcesses_v3
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetComputeRunningProcesses_v3(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_infoCount, nvmlProcessInfo_t *__pyx_v_infos) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetComputeRunningProcesses_v3", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5205
 * cdef nvmlReturn_t _nvmlDeviceGetComputeRunningProcesses_v3(nvmlDevice_t device, unsigned int* infoCount, nvmlProcessInfo_t* infos) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetComputeRunningProcesses_v3
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetComputeRunningProcesses_v3 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5205, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5206
 *     global __nvmlDeviceGetComputeRunningProcesses_v3
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetComputeRunningProcesses_v3 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetComputeRunningProcesses_v3 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetComputeRunningProcesses_v3 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5207
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetComputeRunningProcesses_v3 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetComputeRunningProcesses_v3 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlProcessInfo_t*) noexcept nogil>__nvmlDeviceGetComputeRunningProcesses_v3)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5208
 *     if __nvmlDeviceGetComputeRunningProcesses_v3 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetComputeRunningProcesses_v3 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlProcessInfo_t*) noexcept nogil>__nvmlDeviceGetComputeRunningProcesses_v3)(
 *         device, infoCount, infos)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5208, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetComputeRun};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5208, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5208, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5207
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetComputeRunningProcesses_v3 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetComputeRunningProcesses_v3 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlProcessInfo_t*) noexcept nogil>__nvmlDeviceGetComputeRunningProcesses_v3)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5206
 *     global __nvmlDeviceGetComputeRunningProcesses_v3
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetComputeRunningProcesses_v3 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetComputeRunningProcesses_v3 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5209
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetComputeRunningProcesses_v3 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlProcessInfo_t*) noexcept nogil>__nvmlDeviceGetComputeRunningProcesses_v3)(             # <<<<<<<<<<<<<<
 *         device, infoCount, infos)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *, nvmlProcessInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetComputeRunningProcesses_v3)(__pyx_v_device, __pyx_v_infoCount, __pyx_v_infos);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5203
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetComputeRunningProcesses_v3(nvmlDevice_t device, unsigned int* infoCount, nvmlProcessInfo_t* infos) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetComputeRunningProcesses_v3
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetComputeRunningProcesses_v3", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5213
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMPSComputeRunningProcesses_v3(nvmlDevice_t device, unsigned int* infoCount, nvmlProcessInfo_t* infos) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMPSComputeRunningProcesses_v3
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMPSComputeRunningProcesses_v3(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_infoCount, nvmlProcessInfo_t *__pyx_v_infos) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetMPSComputeRunningProcesses_v3", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5215
 * cdef nvmlReturn_t _nvmlDeviceGetMPSComputeRunningProcesses_v3(nvmlDevice_t device, unsigned int* infoCount, nvmlProcessInfo_t* infos) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetMPSComputeRunningProcesses_v3
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetMPSComputeRunningProcesses_v3 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5215, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5216
 *     global __nvmlDeviceGetMPSComputeRunningProcesses_v3
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMPSComputeRunningProcesses_v3 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMPSComputeRunningProcesses_v3 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMPSComputeRunningProcesses_v3 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5217
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMPSComputeRunningProcesses_v3 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMPSComputeRunningProcesses_v3 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlProcessInfo_t*) noexcept nogil>__nvmlDeviceGetMPSComputeRunningProcesses_v3)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5218
 *     if __nvmlDeviceGetMPSComputeRunningProcesses_v3 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMPSComputeRunningProcesses_v3 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlProcessInfo_t*) noexcept nogil>__nvmlDeviceGetMPSComputeRunningProcesses_v3)(
 *         device, infoCount, infos)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5218, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetMPSCompute};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5218, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5218, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5217
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMPSComputeRunningProcesses_v3 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMPSComputeRunningProcesses_v3 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlProcessInfo_t*) noexcept nogil>__nvmlDeviceGetMPSComputeRunningProcesses_v3)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5216
 *     global __nvmlDeviceGetMPSComputeRunningProcesses_v3
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMPSComputeRunningProcesses_v3 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMPSComputeRunningProcesses_v3 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5219
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMPSComputeRunningProcesses_v3 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlProcessInfo_t*) noexcept nogil>__nvmlDeviceGetMPSComputeRunningProcesses_v3)(             # <<<<<<<<<<<<<<
 *         device, infoCount, infos)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *, nvmlProcessInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMPSComputeRunningProcesses_v3)(__pyx_v_device, __pyx_v_infoCount, __pyx_v_infos);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5213
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMPSComputeRunningProcesses_v3(nvmlDevice_t device, unsigned int* infoCount, nvmlProcessInfo_t* infos) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMPSComputeRunningProcesses_v3
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetMPSComputeRunningProcesses_v3", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5223
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetRunningProcessDetailList(nvmlDevice_t device, nvmlProcessDetailList_t* plist) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetRunningProcessDetailList
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetRunningProcessDetailList(nvmlDevice_t __pyx_v_device, nvmlProcessDetailList_t *__pyx_v_plist) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetRunningProcessDetailList", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5225
 * cdef nvmlReturn_t _nvmlDeviceGetRunningProcessDetailList(nvmlDevice_t device, nvmlProcessDetailList_t* plist) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetRunningProcessDetailList
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetRunningProcessDetailList == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5225, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5226
 *     global __nvmlDeviceGetRunningProcessDetailList
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRunningProcessDetailList == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRunningProcessDetailList is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRunningProcessDetailList == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5227
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRunningProcessDetailList == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetRunningProcessDetailList is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlProcessDetailList_t*) noexcept nogil>__nvmlDeviceGetRunningProcessDetailList)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5228
 *     if __nvmlDeviceGetRunningProcessDetailList == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRunningProcessDetailList is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlProcessDetailList_t*) noexcept nogil>__nvmlDeviceGetRunningProcessDetailList)(
 *         device, plist)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5228, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetRunningPro};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5228, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5228, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5227
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRunningProcessDetailList == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetRunningProcessDetailList is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlProcessDetailList_t*) noexcept nogil>__nvmlDeviceGetRunningProcessDetailList)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5226
 *     global __nvmlDeviceGetRunningProcessDetailList
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRunningProcessDetailList == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRunningProcessDetailList is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5229
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRunningProcessDetailList is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlProcessDetailList_t*) noexcept nogil>__nvmlDeviceGetRunningProcessDetailList)(             # <<<<<<<<<<<<<<
 *         device, plist)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlProcessDetailList_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRunningProcessDetailList)(__pyx_v_device, __pyx_v_plist);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5223
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetRunningProcessDetailList(nvmlDevice_t device, nvmlProcessDetailList_t* plist) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetRunningProcessDetailList
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetRunningProcessDetailList", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5233
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceOnSameBoard(nvmlDevice_t device1, nvmlDevice_t device2, int* onSameBoard) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceOnSameBoard
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceOnSameBoard(nvmlDevice_t __pyx_v_device1, nvmlDevice_t __pyx_v_device2, int *__pyx_v_onSameBoard) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceOnSameBoard", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5235
 * cdef nvmlReturn_t _nvmlDeviceOnSameBoard(nvmlDevice_t device1, nvmlDevice_t device2, int* onSameBoard) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceOnSameBoard
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceOnSameBoard == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5235, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5236
 *     global __nvmlDeviceOnSameBoard
 *     _check_or_init_nvml()
 *     if __nvmlDeviceOnSameBoard == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceOnSameBoard is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceOnSameBoard == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5237
 *     _check_or_init_nvml()
 *     if __nvmlDeviceOnSameBoard == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceOnSameBoard is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevice_t, int*) noexcept nogil>__nvmlDeviceOnSameBoard)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5238
 *     if __nvmlDeviceOnSameBoard == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceOnSameBoard is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevice_t, int*) noexcept nogil>__nvmlDeviceOnSameBoard)(
 *         device1, device2, onSameBoard)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5238, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceOnSameBoard_i};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5238, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5238, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5237
 *     _check_or_init_nvml()
 *     if __nvmlDeviceOnSameBoard == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceOnSameBoard is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevice_t, int*) noexcept nogil>__nvmlDeviceOnSameBoard)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5236
 *     global __nvmlDeviceOnSameBoard
 *     _check_or_init_nvml()
 *     if __nvmlDeviceOnSameBoard == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceOnSameBoard is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5239
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceOnSameBoard is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevice_t, int*) noexcept nogil>__nvmlDeviceOnSameBoard)(             # <<<<<<<<<<<<<<
 *         device1, device2, onSameBoard)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlDevice_t, int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceOnSameBoard)(__pyx_v_device1, __pyx_v_device2, __pyx_v_onSameBoard);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5233
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceOnSameBoard(nvmlDevice_t device1, nvmlDevice_t device2, int* onSameBoard) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceOnSameBoard
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceOnSameBoard", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5243
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetAPIRestriction(nvmlDevice_t device, nvmlRestrictedAPI_t apiType, nvmlEnableState_t* isRestricted) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetAPIRestriction
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetAPIRestriction(nvmlDevice_t __pyx_v_device, nvmlRestrictedAPI_t __pyx_v_apiType, nvmlEnableState_t *__pyx_v_isRestricted) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetAPIRestriction", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5245
 * cdef nvmlReturn_t _nvmlDeviceGetAPIRestriction(nvmlDevice_t device, nvmlRestrictedAPI_t apiType, nvmlEnableState_t* isRestricted) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetAPIRestriction
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetAPIRestriction == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5245, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5246
 *     global __nvmlDeviceGetAPIRestriction
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAPIRestriction == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAPIRestriction is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAPIRestriction == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5247
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAPIRestriction == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetAPIRestriction is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlRestrictedAPI_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetAPIRestriction)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5248
 *     if __nvmlDeviceGetAPIRestriction == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAPIRestriction is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlRestrictedAPI_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetAPIRestriction)(
 *         device, apiType, isRestricted)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5248, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetAPIRestric};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5248, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5248, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5247
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAPIRestriction == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetAPIRestriction is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlRestrictedAPI_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetAPIRestriction)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5246
 *     global __nvmlDeviceGetAPIRestriction
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAPIRestriction == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAPIRestriction is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5249
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAPIRestriction is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlRestrictedAPI_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetAPIRestriction)(             # <<<<<<<<<<<<<<
 *         device, apiType, isRestricted)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlRestrictedAPI_t, nvmlEnableState_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAPIRestriction)(__pyx_v_device, __pyx_v_apiType, __pyx_v_isRestricted);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5243
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetAPIRestriction(nvmlDevice_t device, nvmlRestrictedAPI_t apiType, nvmlEnableState_t* isRestricted) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetAPIRestriction
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetAPIRestriction", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5253
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetSamples(nvmlDevice_t device, nvmlSamplingType_t type, unsigned long long lastSeenTimeStamp, nvmlValueType_t* sampleValType, unsigned int* sampleCount, nvmlSample_t* samples) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetSamples
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetSamples(nvmlDevice_t __pyx_v_device, nvmlSamplingType_t __pyx_v_type, unsigned PY_LONG_LONG __pyx_v_lastSeenTimeStamp, nvmlValueType_t *__pyx_v_sampleValType, unsigned int *__pyx_v_sampleCount, nvmlSample_t *__pyx_v_samples) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetSamples", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5255
 * cdef nvmlReturn_t _nvmlDeviceGetSamples(nvmlDevice_t device, nvmlSamplingType_t type, unsigned long long lastSeenTimeStamp, nvmlValueType_t* sampleValType, unsigned int* sampleCount, nvmlSample_t* samples) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetSamples
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetSamples == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5255, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5256
 *     global __nvmlDeviceGetSamples
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSamples == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSamples is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSamples == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5257
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSamples == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetSamples is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlSamplingType_t, unsigned long long, nvmlValueType_t*, unsigned int*, nvmlSample_t*) noexcept nogil>__nvmlDeviceGetSamples)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5258
 *     if __nvmlDeviceGetSamples == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSamples is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlSamplingType_t, unsigned long long, nvmlValueType_t*, unsigned int*, nvmlSample_t*) noexcept nogil>__nvmlDeviceGetSamples)(
 *         device, type, lastSeenTimeStamp, sampleValType, sampleCount, samples)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5258, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetSamples_is};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5258, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5258, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5257
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSamples == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetSamples is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlSamplingType_t, unsigned long long, nvmlValueType_t*, unsigned int*, nvmlSample_t*) noexcept nogil>__nvmlDeviceGetSamples)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5256
 *     global __nvmlDeviceGetSamples
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSamples == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSamples is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5259
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSamples is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlSamplingType_t, unsigned long long, nvmlValueType_t*, unsigned int*, nvmlSample_t*) noexcept nogil>__nvmlDeviceGetSamples)(             # <<<<<<<<<<<<<<
 *         device, type, lastSeenTimeStamp, sampleValType, sampleCount, samples)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlSamplingType_t, unsigned PY_LONG_LONG, nvmlValueType_t *, unsigned int *, nvmlSample_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSamples)(__pyx_v_device, __pyx_v_type, __pyx_v_lastSeenTimeStamp, __pyx_v_sampleValType, __pyx_v_sampleCount, __pyx_v_samples);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5253
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetSamples(nvmlDevice_t device, nvmlSamplingType_t type, unsigned long long lastSeenTimeStamp, nvmlValueType_t* sampleValType, unsigned int* sampleCount, nvmlSample_t* samples) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetSamples
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetSamples", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5263
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetBAR1MemoryInfo(nvmlDevice_t device, nvmlBAR1Memory_t* bar1Memory) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetBAR1MemoryInfo
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetBAR1MemoryInfo(nvmlDevice_t __pyx_v_device, nvmlBAR1Memory_t *__pyx_v_bar1Memory) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetBAR1MemoryInfo", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5265
 * cdef nvmlReturn_t _nvmlDeviceGetBAR1MemoryInfo(nvmlDevice_t device, nvmlBAR1Memory_t* bar1Memory) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetBAR1MemoryInfo
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetBAR1MemoryInfo == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5265, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5266
 *     global __nvmlDeviceGetBAR1MemoryInfo
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetBAR1MemoryInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetBAR1MemoryInfo is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBAR1MemoryInfo == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5267
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetBAR1MemoryInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetBAR1MemoryInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlBAR1Memory_t*) noexcept nogil>__nvmlDeviceGetBAR1MemoryInfo)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5268
 *     if __nvmlDeviceGetBAR1MemoryInfo == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetBAR1MemoryInfo is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlBAR1Memory_t*) noexcept nogil>__nvmlDeviceGetBAR1MemoryInfo)(
 *         device, bar1Memory)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5268, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetBAR1Memory};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5268, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5268, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5267
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetBAR1MemoryInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetBAR1MemoryInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlBAR1Memory_t*) noexcept nogil>__nvmlDeviceGetBAR1MemoryInfo)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5266
 *     global __nvmlDeviceGetBAR1MemoryInfo
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetBAR1MemoryInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetBAR1MemoryInfo is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5269
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetBAR1MemoryInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlBAR1Memory_t*) noexcept nogil>__nvmlDeviceGetBAR1MemoryInfo)(             # <<<<<<<<<<<<<<
 *         device, bar1Memory)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlBAR1Memory_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBAR1MemoryInfo)(__pyx_v_device, __pyx_v_bar1Memory);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5263
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetBAR1MemoryInfo(nvmlDevice_t device, nvmlBAR1Memory_t* bar1Memory) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetBAR1MemoryInfo
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetBAR1MemoryInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5273
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetIrqNum(nvmlDevice_t device, unsigned int* irqNum) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetIrqNum
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetIrqNum(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_irqNum) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetIrqNum", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5275
 * cdef nvmlReturn_t _nvmlDeviceGetIrqNum(nvmlDevice_t device, unsigned int* irqNum) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetIrqNum
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetIrqNum == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5275, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5276
 *     global __nvmlDeviceGetIrqNum
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetIrqNum == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetIrqNum is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetIrqNum == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5277
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetIrqNum == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetIrqNum is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetIrqNum)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5278
 *     if __nvmlDeviceGetIrqNum == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetIrqNum is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetIrqNum)(
 *         device, irqNum)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5278, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetIrqNum_is};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5278, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5278, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5277
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetIrqNum == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetIrqNum is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetIrqNum)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5276
 *     global __nvmlDeviceGetIrqNum
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetIrqNum == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetIrqNum is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5279
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetIrqNum is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetIrqNum)(             # <<<<<<<<<<<<<<
 *         device, irqNum)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetIrqNum)(__pyx_v_device, __pyx_v_irqNum);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5273
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetIrqNum(nvmlDevice_t device, unsigned int* irqNum) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetIrqNum
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetIrqNum", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5283
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetNumGpuCores(nvmlDevice_t device, unsigned int* numCores) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetNumGpuCores
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetNumGpuCores(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_numCores) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetNumGpuCores", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5285
 * cdef nvmlReturn_t _nvmlDeviceGetNumGpuCores(nvmlDevice_t device, unsigned int* numCores) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetNumGpuCores
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetNumGpuCores == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5285, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5286
 *     global __nvmlDeviceGetNumGpuCores
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNumGpuCores == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNumGpuCores is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNumGpuCores == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5287
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNumGpuCores == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetNumGpuCores is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetNumGpuCores)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5288
 *     if __nvmlDeviceGetNumGpuCores == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNumGpuCores is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetNumGpuCores)(
 *         device, numCores)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5288, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetNumGpuCore};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5288, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5288, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5287
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNumGpuCores == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetNumGpuCores is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetNumGpuCores)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5286
 *     global __nvmlDeviceGetNumGpuCores
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNumGpuCores == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNumGpuCores is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5289
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNumGpuCores is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetNumGpuCores)(             # <<<<<<<<<<<<<<
 *         device, numCores)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNumGpuCores)(__pyx_v_device, __pyx_v_numCores);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5283
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetNumGpuCores(nvmlDevice_t device, unsigned int* numCores) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetNumGpuCores
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetNumGpuCores", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5293
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPowerSource(nvmlDevice_t device, nvmlPowerSource_t* powerSource) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPowerSource
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPowerSource(nvmlDevice_t __pyx_v_device, nvmlPowerSource_t *__pyx_v_powerSource) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetPowerSource", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5295
 * cdef nvmlReturn_t _nvmlDeviceGetPowerSource(nvmlDevice_t device, nvmlPowerSource_t* powerSource) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetPowerSource
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetPowerSource == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5295, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5296
 *     global __nvmlDeviceGetPowerSource
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerSource == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerSource is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerSource == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5297
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerSource == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerSource is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerSource_t*) noexcept nogil>__nvmlDeviceGetPowerSource)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5298
 *     if __nvmlDeviceGetPowerSource == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerSource is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerSource_t*) noexcept nogil>__nvmlDeviceGetPowerSource)(
 *         device, powerSource)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5298, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetPowerSourc};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5298, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5298, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5297
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerSource == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerSource is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerSource_t*) noexcept nogil>__nvmlDeviceGetPowerSource)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5296
 *     global __nvmlDeviceGetPowerSource
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerSource == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerSource is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5299
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerSource is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerSource_t*) noexcept nogil>__nvmlDeviceGetPowerSource)(             # <<<<<<<<<<<<<<
 *         device, powerSource)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerSource_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerSource)(__pyx_v_device, __pyx_v_powerSource);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5293
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPowerSource(nvmlDevice_t device, nvmlPowerSource_t* powerSource) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPowerSource
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetPowerSource", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5303
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMemoryBusWidth(nvmlDevice_t device, unsigned int* busWidth) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMemoryBusWidth
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMemoryBusWidth(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_busWidth) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetMemoryBusWidth", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5305
 * cdef nvmlReturn_t _nvmlDeviceGetMemoryBusWidth(nvmlDevice_t device, unsigned int* busWidth) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetMemoryBusWidth
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetMemoryBusWidth == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5305, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5306
 *     global __nvmlDeviceGetMemoryBusWidth
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMemoryBusWidth == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemoryBusWidth is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryBusWidth == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5307
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMemoryBusWidth == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemoryBusWidth is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMemoryBusWidth)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5308
 *     if __nvmlDeviceGetMemoryBusWidth == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemoryBusWidth is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMemoryBusWidth)(
 *         device, busWidth)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5308, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetMemoryBusW};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5308, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5308, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5307
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMemoryBusWidth == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemoryBusWidth is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMemoryBusWidth)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5306
 *     global __nvmlDeviceGetMemoryBusWidth
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMemoryBusWidth == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemoryBusWidth is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5309
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMemoryBusWidth is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMemoryBusWidth)(             # <<<<<<<<<<<<<<
 *         device, busWidth)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryBusWidth)(__pyx_v_device, __pyx_v_busWidth);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5303
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMemoryBusWidth(nvmlDevice_t device, unsigned int* busWidth) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMemoryBusWidth
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetMemoryBusWidth", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5313
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPcieLinkMaxSpeed(nvmlDevice_t device, unsigned int* maxSpeed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPcieLinkMaxSpeed
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPcieLinkMaxSpeed(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_maxSpeed) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetPcieLinkMaxSpeed", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5315
 * cdef nvmlReturn_t _nvmlDeviceGetPcieLinkMaxSpeed(nvmlDevice_t device, unsigned int* maxSpeed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetPcieLinkMaxSpeed
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetPcieLinkMaxSpeed == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5315, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5316
 *     global __nvmlDeviceGetPcieLinkMaxSpeed
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPcieLinkMaxSpeed == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPcieLinkMaxSpeed is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieLinkMaxSpeed == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5317
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPcieLinkMaxSpeed == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPcieLinkMaxSpeed is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPcieLinkMaxSpeed)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5318
 *     if __nvmlDeviceGetPcieLinkMaxSpeed == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPcieLinkMaxSpeed is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPcieLinkMaxSpeed)(
 *         device, maxSpeed)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5318, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetPcieLinkMa};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5318, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5318, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5317
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPcieLinkMaxSpeed == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPcieLinkMaxSpeed is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPcieLinkMaxSpeed)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5316
 *     global __nvmlDeviceGetPcieLinkMaxSpeed
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPcieLinkMaxSpeed == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPcieLinkMaxSpeed is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5319
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPcieLinkMaxSpeed is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPcieLinkMaxSpeed)(             # <<<<<<<<<<<<<<
 *         device, maxSpeed)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieLinkMaxSpeed)(__pyx_v_device, __pyx_v_maxSpeed);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5313
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPcieLinkMaxSpeed(nvmlDevice_t device, unsigned int* maxSpeed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPcieLinkMaxSpeed
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetPcieLinkMaxSpeed", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5323
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPcieSpeed(nvmlDevice_t device, unsigned int* pcieSpeed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPcieSpeed
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPcieSpeed(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_pcieSpeed) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetPcieSpeed", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5325
 * cdef nvmlReturn_t _nvmlDeviceGetPcieSpeed(nvmlDevice_t device, unsigned int* pcieSpeed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetPcieSpeed
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetPcieSpeed == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5325, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5326
 *     global __nvmlDeviceGetPcieSpeed
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPcieSpeed == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPcieSpeed is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieSpeed == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5327
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPcieSpeed == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPcieSpeed is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPcieSpeed)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5328
 *     if __nvmlDeviceGetPcieSpeed == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPcieSpeed is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPcieSpeed)(
 *         device, pcieSpeed)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5328, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetPcieSpeed};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5328, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5328, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5327
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPcieSpeed == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPcieSpeed is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPcieSpeed)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5326
 *     global __nvmlDeviceGetPcieSpeed
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPcieSpeed == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPcieSpeed is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5329
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPcieSpeed is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetPcieSpeed)(             # <<<<<<<<<<<<<<
 *         device, pcieSpeed)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieSpeed)(__pyx_v_device, __pyx_v_pcieSpeed);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5323
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPcieSpeed(nvmlDevice_t device, unsigned int* pcieSpeed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPcieSpeed
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetPcieSpeed", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5333
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetAdaptiveClockInfoStatus(nvmlDevice_t device, unsigned int* adaptiveClockStatus) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetAdaptiveClockInfoStatus
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetAdaptiveClockInfoStatus(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_adaptiveClockStatus) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetAdaptiveClockInfoStatus", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5335
 * cdef nvmlReturn_t _nvmlDeviceGetAdaptiveClockInfoStatus(nvmlDevice_t device, unsigned int* adaptiveClockStatus) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetAdaptiveClockInfoStatus
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetAdaptiveClockInfoStatus == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5335, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5336
 *     global __nvmlDeviceGetAdaptiveClockInfoStatus
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAdaptiveClockInfoStatus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAdaptiveClockInfoStatus is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAdaptiveClockInfoStatus == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5337
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAdaptiveClockInfoStatus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetAdaptiveClockInfoStatus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetAdaptiveClockInfoStatus)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5338
 *     if __nvmlDeviceGetAdaptiveClockInfoStatus == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAdaptiveClockInfoStatus is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetAdaptiveClockInfoStatus)(
 *         device, adaptiveClockStatus)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5338, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetAdaptiveCl};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5338, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5338, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5337
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAdaptiveClockInfoStatus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetAdaptiveClockInfoStatus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetAdaptiveClockInfoStatus)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5336
 *     global __nvmlDeviceGetAdaptiveClockInfoStatus
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAdaptiveClockInfoStatus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAdaptiveClockInfoStatus is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5339
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAdaptiveClockInfoStatus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetAdaptiveClockInfoStatus)(             # <<<<<<<<<<<<<<
 *         device, adaptiveClockStatus)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAdaptiveClockInfoStatus)(__pyx_v_device, __pyx_v_adaptiveClockStatus);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5333
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetAdaptiveClockInfoStatus(nvmlDevice_t device, unsigned int* adaptiveClockStatus) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetAdaptiveClockInfoStatus
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetAdaptiveClockInfoStatus", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5343
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetBusType(nvmlDevice_t device, nvmlBusType_t* type) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetBusType
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetBusType(nvmlDevice_t __pyx_v_device, nvmlBusType_t *__pyx_v_type) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetBusType", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5345
 * cdef nvmlReturn_t _nvmlDeviceGetBusType(nvmlDevice_t device, nvmlBusType_t* type) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetBusType
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetBusType == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5345, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5346
 *     global __nvmlDeviceGetBusType
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetBusType == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetBusType is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBusType == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5347
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetBusType == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetBusType is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlBusType_t*) noexcept nogil>__nvmlDeviceGetBusType)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5348
 *     if __nvmlDeviceGetBusType == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetBusType is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlBusType_t*) noexcept nogil>__nvmlDeviceGetBusType)(
 *         device, type)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5348, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetBusType_is};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5348, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5348, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5347
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetBusType == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetBusType is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlBusType_t*) noexcept nogil>__nvmlDeviceGetBusType)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5346
 *     global __nvmlDeviceGetBusType
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetBusType == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetBusType is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5349
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetBusType is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlBusType_t*) noexcept nogil>__nvmlDeviceGetBusType)(             # <<<<<<<<<<<<<<
 *         device, type)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlBusType_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBusType)(__pyx_v_device, __pyx_v_type);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5343
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetBusType(nvmlDevice_t device, nvmlBusType_t* type) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetBusType
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetBusType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5353
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGpuFabricInfoV(nvmlDevice_t device, nvmlGpuFabricInfoV_t* gpuFabricInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGpuFabricInfoV
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGpuFabricInfoV(nvmlDevice_t __pyx_v_device, nvmlGpuFabricInfoV_t *__pyx_v_gpuFabricInfo) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetGpuFabricInfoV", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5355
 * cdef nvmlReturn_t _nvmlDeviceGetGpuFabricInfoV(nvmlDevice_t device, nvmlGpuFabricInfoV_t* gpuFabricInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetGpuFabricInfoV
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetGpuFabricInfoV == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5355, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5356
 *     global __nvmlDeviceGetGpuFabricInfoV
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuFabricInfoV == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuFabricInfoV is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuFabricInfoV == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5357
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuFabricInfoV == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuFabricInfoV is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuFabricInfoV_t*) noexcept nogil>__nvmlDeviceGetGpuFabricInfoV)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5358
 *     if __nvmlDeviceGetGpuFabricInfoV == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuFabricInfoV is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuFabricInfoV_t*) noexcept nogil>__nvmlDeviceGetGpuFabricInfoV)(
 *         device, gpuFabricInfo)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5358, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetGpuFabricI};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5358, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5358, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5357
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuFabricInfoV == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuFabricInfoV is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuFabricInfoV_t*) noexcept nogil>__nvmlDeviceGetGpuFabricInfoV)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5356
 *     global __nvmlDeviceGetGpuFabricInfoV
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuFabricInfoV == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuFabricInfoV is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5359
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuFabricInfoV is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuFabricInfoV_t*) noexcept nogil>__nvmlDeviceGetGpuFabricInfoV)(             # <<<<<<<<<<<<<<
 *         device, gpuFabricInfo)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuFabricInfoV_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuFabricInfoV)(__pyx_v_device, __pyx_v_gpuFabricInfo);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5353
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGpuFabricInfoV(nvmlDevice_t device, nvmlGpuFabricInfoV_t* gpuFabricInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGpuFabricInfoV
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetGpuFabricInfoV", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5363
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetConfComputeCapabilities(nvmlConfComputeSystemCaps_t* capabilities) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetConfComputeCapabilities
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetConfComputeCapabilities(nvmlConfComputeSystemCaps_t *__pyx_v_capabilities) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlSystemGetConfComputeCapabilities", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5365
 * cdef nvmlReturn_t _nvmlSystemGetConfComputeCapabilities(nvmlConfComputeSystemCaps_t* capabilities) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlSystemGetConfComputeCapabilities
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlSystemGetConfComputeCapabilities == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5365, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5366
 *     global __nvmlSystemGetConfComputeCapabilities
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetConfComputeCapabilities == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeCapabilities is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeCapabilities == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5367
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetConfComputeCapabilities == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeCapabilities is not found")
 *     return (<nvmlReturn_t (*)(nvmlConfComputeSystemCaps_t*) noexcept nogil>__nvmlSystemGetConfComputeCapabilities)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5368
 *     if __nvmlSystemGetConfComputeCapabilities == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeCapabilities is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlConfComputeSystemCaps_t*) noexcept nogil>__nvmlSystemGetConfComputeCapabilities)(
 *         capabilities)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5368, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlSystemGetConfComput};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5368, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5368, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5367
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetConfComputeCapabilities == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeCapabilities is not found")
 *     return (<nvmlReturn_t (*)(nvmlConfComputeSystemCaps_t*) noexcept nogil>__nvmlSystemGetConfComputeCapabilities)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5366
 *     global __nvmlSystemGetConfComputeCapabilities
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetConfComputeCapabilities == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeCapabilities is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5369
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeCapabilities is not found")
 *     return (<nvmlReturn_t (*)(nvmlConfComputeSystemCaps_t*) noexcept nogil>__nvmlSystemGetConfComputeCapabilities)(             # <<<<<<<<<<<<<<
 *         capabilities)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlConfComputeSystemCaps_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeCapabilities)(__pyx_v_capabilities);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5363
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetConfComputeCapabilities(nvmlConfComputeSystemCaps_t* capabilities) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetConfComputeCapabilities
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlSystemGetConfComputeCapabilities", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5373
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetConfComputeState(nvmlConfComputeSystemState_t* state) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetConfComputeState
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetConfComputeState(nvmlConfComputeSystemState_t *__pyx_v_state) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlSystemGetConfComputeState", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5375
 * cdef nvmlReturn_t _nvmlSystemGetConfComputeState(nvmlConfComputeSystemState_t* state) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlSystemGetConfComputeState
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlSystemGetConfComputeState == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5375, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5376
 *     global __nvmlSystemGetConfComputeState
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetConfComputeState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeState is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeState == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5377
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetConfComputeState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeState is not found")
 *     return (<nvmlReturn_t (*)(nvmlConfComputeSystemState_t*) noexcept nogil>__nvmlSystemGetConfComputeState)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5378
 *     if __nvmlSystemGetConfComputeState == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeState is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlConfComputeSystemState_t*) noexcept nogil>__nvmlSystemGetConfComputeState)(
 *         state)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5378, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlSystemGetConfComput_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5378, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5378, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5377
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetConfComputeState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeState is not found")
 *     return (<nvmlReturn_t (*)(nvmlConfComputeSystemState_t*) noexcept nogil>__nvmlSystemGetConfComputeState)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5376
 *     global __nvmlSystemGetConfComputeState
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetConfComputeState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeState is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5379
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeState is not found")
 *     return (<nvmlReturn_t (*)(nvmlConfComputeSystemState_t*) noexcept nogil>__nvmlSystemGetConfComputeState)(             # <<<<<<<<<<<<<<
 *         state)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlConfComputeSystemState_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeState)(__pyx_v_state);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5373
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetConfComputeState(nvmlConfComputeSystemState_t* state) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetConfComputeState
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlSystemGetConfComputeState", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5383
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetConfComputeMemSizeInfo(nvmlDevice_t device, nvmlConfComputeMemSizeInfo_t* memInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetConfComputeMemSizeInfo
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetConfComputeMemSizeInfo(nvmlDevice_t __pyx_v_device, nvmlConfComputeMemSizeInfo_t *__pyx_v_memInfo) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetConfComputeMemSizeInfo", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5385
 * cdef nvmlReturn_t _nvmlDeviceGetConfComputeMemSizeInfo(nvmlDevice_t device, nvmlConfComputeMemSizeInfo_t* memInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetConfComputeMemSizeInfo
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetConfComputeMemSizeInfo == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5385, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5386
 *     global __nvmlDeviceGetConfComputeMemSizeInfo
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetConfComputeMemSizeInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetConfComputeMemSizeInfo is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeMemSizeInfo == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5387
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetConfComputeMemSizeInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetConfComputeMemSizeInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlConfComputeMemSizeInfo_t*) noexcept nogil>__nvmlDeviceGetConfComputeMemSizeInfo)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5388
 *     if __nvmlDeviceGetConfComputeMemSizeInfo == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetConfComputeMemSizeInfo is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlConfComputeMemSizeInfo_t*) noexcept nogil>__nvmlDeviceGetConfComputeMemSizeInfo)(
 *         device, memInfo)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5388, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetConfComput};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5388, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5388, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5387
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetConfComputeMemSizeInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetConfComputeMemSizeInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlConfComputeMemSizeInfo_t*) noexcept nogil>__nvmlDeviceGetConfComputeMemSizeInfo)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5386
 *     global __nvmlDeviceGetConfComputeMemSizeInfo
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetConfComputeMemSizeInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetConfComputeMemSizeInfo is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5389
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetConfComputeMemSizeInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlConfComputeMemSizeInfo_t*) noexcept nogil>__nvmlDeviceGetConfComputeMemSizeInfo)(             # <<<<<<<<<<<<<<
 *         device, memInfo)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlConfComputeMemSizeInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeMemSizeInfo)(__pyx_v_device, __pyx_v_memInfo);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5383
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetConfComputeMemSizeInfo(nvmlDevice_t device, nvmlConfComputeMemSizeInfo_t* memInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetConfComputeMemSizeInfo
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetConfComputeMemSizeInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5393
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetConfComputeGpusReadyState(unsigned int* isAcceptingWork) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetConfComputeGpusReadyState
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetConfComputeGpusReadyState(unsigned int *__pyx_v_isAcceptingWork) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlSystemGetConfComputeGpusReadyState", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5395
 * cdef nvmlReturn_t _nvmlSystemGetConfComputeGpusReadyState(unsigned int* isAcceptingWork) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlSystemGetConfComputeGpusReadyState
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlSystemGetConfComputeGpusReadyState == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5395, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5396
 *     global __nvmlSystemGetConfComputeGpusReadyState
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetConfComputeGpusReadyState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeGpusReadyState is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeGpusReadyState == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5397
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetConfComputeGpusReadyState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeGpusReadyState is not found")
 *     return (<nvmlReturn_t (*)(unsigned int*) noexcept nogil>__nvmlSystemGetConfComputeGpusReadyState)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5398
 *     if __nvmlSystemGetConfComputeGpusReadyState == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeGpusReadyState is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(unsigned int*) noexcept nogil>__nvmlSystemGetConfComputeGpusReadyState)(
 *         isAcceptingWork)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5398, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlSystemGetConfComput_3};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5398, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5398, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5397
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetConfComputeGpusReadyState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeGpusReadyState is not found")
 *     return (<nvmlReturn_t (*)(unsigned int*) noexcept nogil>__nvmlSystemGetConfComputeGpusReadyState)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5396
 *     global __nvmlSystemGetConfComputeGpusReadyState
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetConfComputeGpusReadyState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeGpusReadyState is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5399
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeGpusReadyState is not found")
 *     return (<nvmlReturn_t (*)(unsigned int*) noexcept nogil>__nvmlSystemGetConfComputeGpusReadyState)(             # <<<<<<<<<<<<<<
 *         isAcceptingWork)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeGpusReadyState)(__pyx_v_isAcceptingWork);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5393
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetConfComputeGpusReadyState(unsigned int* isAcceptingWork) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetConfComputeGpusReadyState
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlSystemGetConfComputeGpusReadyState", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5403
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetConfComputeProtectedMemoryUsage(nvmlDevice_t device, nvmlMemory_t* memory) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetConfComputeProtectedMemoryUsage
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetConfComputeProtectedMemoryUsage(nvmlDevice_t __pyx_v_device, nvmlMemory_t *__pyx_v_memory) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetConfComputeProtectedMemoryUsage", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5405
 * cdef nvmlReturn_t _nvmlDeviceGetConfComputeProtectedMemoryUsage(nvmlDevice_t device, nvmlMemory_t* memory) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetConfComputeProtectedMemoryUsage
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetConfComputeProtectedMemoryUsage == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5405, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5406
 *     global __nvmlDeviceGetConfComputeProtectedMemoryUsage
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetConfComputeProtectedMemoryUsage == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetConfComputeProtectedMemoryUsage is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeProtectedMemoryUsage == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5407
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetConfComputeProtectedMemoryUsage == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetConfComputeProtectedMemoryUsage is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlMemory_t*) noexcept nogil>__nvmlDeviceGetConfComputeProtectedMemoryUsage)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5408
 *     if __nvmlDeviceGetConfComputeProtectedMemoryUsage == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetConfComputeProtectedMemoryUsage is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlMemory_t*) noexcept nogil>__nvmlDeviceGetConfComputeProtectedMemoryUsage)(
 *         device, memory)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5408, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetConfComput_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5408, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5408, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5407
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetConfComputeProtectedMemoryUsage == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetConfComputeProtectedMemoryUsage is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlMemory_t*) noexcept nogil>__nvmlDeviceGetConfComputeProtectedMemoryUsage)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5406
 *     global __nvmlDeviceGetConfComputeProtectedMemoryUsage
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetConfComputeProtectedMemoryUsage == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetConfComputeProtectedMemoryUsage is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5409
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetConfComputeProtectedMemoryUsage is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlMemory_t*) noexcept nogil>__nvmlDeviceGetConfComputeProtectedMemoryUsage)(             # <<<<<<<<<<<<<<
 *         device, memory)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlMemory_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeProtectedMemoryUsage)(__pyx_v_device, __pyx_v_memory);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5403
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetConfComputeProtectedMemoryUsage(nvmlDevice_t device, nvmlMemory_t* memory) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetConfComputeProtectedMemoryUsage
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetConfComputeProtectedMemoryUsage", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5413
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetConfComputeGpuCertificate(nvmlDevice_t device, nvmlConfComputeGpuCertificate_t* gpuCert) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetConfComputeGpuCertificate
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetConfComputeGpuCertificate(nvmlDevice_t __pyx_v_device, nvmlConfComputeGpuCertificate_t *__pyx_v_gpuCert) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetConfComputeGpuCertificate", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5415
 * cdef nvmlReturn_t _nvmlDeviceGetConfComputeGpuCertificate(nvmlDevice_t device, nvmlConfComputeGpuCertificate_t* gpuCert) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetConfComputeGpuCertificate
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetConfComputeGpuCertificate == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5415, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5416
 *     global __nvmlDeviceGetConfComputeGpuCertificate
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetConfComputeGpuCertificate == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetConfComputeGpuCertificate is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeGpuCertificate == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5417
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetConfComputeGpuCertificate == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetConfComputeGpuCertificate is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlConfComputeGpuCertificate_t*) noexcept nogil>__nvmlDeviceGetConfComputeGpuCertificate)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5418
 *     if __nvmlDeviceGetConfComputeGpuCertificate == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetConfComputeGpuCertificate is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlConfComputeGpuCertificate_t*) noexcept nogil>__nvmlDeviceGetConfComputeGpuCertificate)(
 *         device, gpuCert)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5418, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetConfComput_3};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5418, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5418, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5417
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetConfComputeGpuCertificate == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetConfComputeGpuCertificate is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlConfComputeGpuCertificate_t*) noexcept nogil>__nvmlDeviceGetConfComputeGpuCertificate)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5416
 *     global __nvmlDeviceGetConfComputeGpuCertificate
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetConfComputeGpuCertificate == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetConfComputeGpuCertificate is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5419
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetConfComputeGpuCertificate is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlConfComputeGpuCertificate_t*) noexcept nogil>__nvmlDeviceGetConfComputeGpuCertificate)(             # <<<<<<<<<<<<<<
 *         device, gpuCert)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlConfComputeGpuCertificate_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeGpuCertificate)(__pyx_v_device, __pyx_v_gpuCert);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5413
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetConfComputeGpuCertificate(nvmlDevice_t device, nvmlConfComputeGpuCertificate_t* gpuCert) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetConfComputeGpuCertificate
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetConfComputeGpuCertificate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5423
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetConfComputeGpuAttestationReport(nvmlDevice_t device, nvmlConfComputeGpuAttestationReport_t* gpuAtstReport) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetConfComputeGpuAttestationReport
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetConfComputeGpuAttestationReport(nvmlDevice_t __pyx_v_device, nvmlConfComputeGpuAttestationReport_t *__pyx_v_gpuAtstReport) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetConfComputeGpuAttestationReport", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5425
 * cdef nvmlReturn_t _nvmlDeviceGetConfComputeGpuAttestationReport(nvmlDevice_t device, nvmlConfComputeGpuAttestationReport_t* gpuAtstReport) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetConfComputeGpuAttestationReport
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetConfComputeGpuAttestationReport == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5425, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5426
 *     global __nvmlDeviceGetConfComputeGpuAttestationReport
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetConfComputeGpuAttestationReport == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetConfComputeGpuAttestationReport is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeGpuAttestationReport == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5427
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetConfComputeGpuAttestationReport == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetConfComputeGpuAttestationReport is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlConfComputeGpuAttestationReport_t*) noexcept nogil>__nvmlDeviceGetConfComputeGpuAttestationReport)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5428
 *     if __nvmlDeviceGetConfComputeGpuAttestationReport == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetConfComputeGpuAttestationReport is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlConfComputeGpuAttestationReport_t*) noexcept nogil>__nvmlDeviceGetConfComputeGpuAttestationReport)(
 *         device, gpuAtstReport)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5428, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetConfComput_4};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5428, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5428, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5427
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetConfComputeGpuAttestationReport == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetConfComputeGpuAttestationReport is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlConfComputeGpuAttestationReport_t*) noexcept nogil>__nvmlDeviceGetConfComputeGpuAttestationReport)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5426
 *     global __nvmlDeviceGetConfComputeGpuAttestationReport
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetConfComputeGpuAttestationReport == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetConfComputeGpuAttestationReport is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5429
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetConfComputeGpuAttestationReport is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlConfComputeGpuAttestationReport_t*) noexcept nogil>__nvmlDeviceGetConfComputeGpuAttestationReport)(             # <<<<<<<<<<<<<<
 *         device, gpuAtstReport)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlConfComputeGpuAttestationReport_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeGpuAttestationReport)(__pyx_v_device, __pyx_v_gpuAtstReport);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5423
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetConfComputeGpuAttestationReport(nvmlDevice_t device, nvmlConfComputeGpuAttestationReport_t* gpuAtstReport) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetConfComputeGpuAttestationReport
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetConfComputeGpuAttestationReport", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5433
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetConfComputeKeyRotationThresholdInfo(nvmlConfComputeGetKeyRotationThresholdInfo_t* pKeyRotationThrInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetConfComputeKeyRotationThresholdInfo
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetConfComputeKeyRotationThresholdInfo(nvmlConfComputeGetKeyRotationThresholdInfo_t *__pyx_v_pKeyRotationThrInfo) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlSystemGetConfComputeKeyRotationThresholdInfo", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5435
 * cdef nvmlReturn_t _nvmlSystemGetConfComputeKeyRotationThresholdInfo(nvmlConfComputeGetKeyRotationThresholdInfo_t* pKeyRotationThrInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlSystemGetConfComputeKeyRotationThresholdInfo
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlSystemGetConfComputeKeyRotationThresholdInfo == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5435, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5436
 *     global __nvmlSystemGetConfComputeKeyRotationThresholdInfo
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetConfComputeKeyRotationThresholdInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeKeyRotationThresholdInfo is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeKeyRotationThresholdInfo == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5437
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetConfComputeKeyRotationThresholdInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeKeyRotationThresholdInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlConfComputeGetKeyRotationThresholdInfo_t*) noexcept nogil>__nvmlSystemGetConfComputeKeyRotationThresholdInfo)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5438
 *     if __nvmlSystemGetConfComputeKeyRotationThresholdInfo == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeKeyRotationThresholdInfo is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlConfComputeGetKeyRotationThresholdInfo_t*) noexcept nogil>__nvmlSystemGetConfComputeKeyRotationThresholdInfo)(
 *         pKeyRotationThrInfo)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5438, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlSystemGetConfComput_4};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5438, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5438, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5437
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetConfComputeKeyRotationThresholdInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeKeyRotationThresholdInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlConfComputeGetKeyRotationThresholdInfo_t*) noexcept nogil>__nvmlSystemGetConfComputeKeyRotationThresholdInfo)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5436
 *     global __nvmlSystemGetConfComputeKeyRotationThresholdInfo
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetConfComputeKeyRotationThresholdInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeKeyRotationThresholdInfo is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5439
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeKeyRotationThresholdInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlConfComputeGetKeyRotationThresholdInfo_t*) noexcept nogil>__nvmlSystemGetConfComputeKeyRotationThresholdInfo)(             # <<<<<<<<<<<<<<
 *         pKeyRotationThrInfo)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlConfComputeGetKeyRotationThresholdInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeKeyRotationThresholdInfo)(__pyx_v_pKeyRotationThrInfo);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5433
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetConfComputeKeyRotationThresholdInfo(nvmlConfComputeGetKeyRotationThresholdInfo_t* pKeyRotationThrInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetConfComputeKeyRotationThresholdInfo
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlSystemGetConfComputeKeyRotationThresholdInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5443
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetConfComputeUnprotectedMemSize(nvmlDevice_t device, unsigned long long sizeKiB) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetConfComputeUnprotectedMemSize
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetConfComputeUnprotectedMemSize(nvmlDevice_t __pyx_v_device, unsigned PY_LONG_LONG __pyx_v_sizeKiB) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetConfComputeUnprotectedMemSize", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5445
 * cdef nvmlReturn_t _nvmlDeviceSetConfComputeUnprotectedMemSize(nvmlDevice_t device, unsigned long long sizeKiB) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetConfComputeUnprotectedMemSize
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetConfComputeUnprotectedMemSize == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5445, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5446
 *     global __nvmlDeviceSetConfComputeUnprotectedMemSize
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetConfComputeUnprotectedMemSize == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetConfComputeUnprotectedMemSize is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetConfComputeUnprotectedMemSize == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5447
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetConfComputeUnprotectedMemSize == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetConfComputeUnprotectedMemSize is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long) noexcept nogil>__nvmlDeviceSetConfComputeUnprotectedMemSize)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5448
 *     if __nvmlDeviceSetConfComputeUnprotectedMemSize == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetConfComputeUnprotectedMemSize is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long) noexcept nogil>__nvmlDeviceSetConfComputeUnprotectedMemSize)(
 *         device, sizeKiB)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5448, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetConfComput};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5448, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5448, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5447
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetConfComputeUnprotectedMemSize == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetConfComputeUnprotectedMemSize is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long) noexcept nogil>__nvmlDeviceSetConfComputeUnprotectedMemSize)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5446
 *     global __nvmlDeviceSetConfComputeUnprotectedMemSize
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetConfComputeUnprotectedMemSize == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetConfComputeUnprotectedMemSize is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5449
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetConfComputeUnprotectedMemSize is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long) noexcept nogil>__nvmlDeviceSetConfComputeUnprotectedMemSize)(             # <<<<<<<<<<<<<<
 *         device, sizeKiB)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned PY_LONG_LONG))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetConfComputeUnprotectedMemSize)(__pyx_v_device, __pyx_v_sizeKiB);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5443
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetConfComputeUnprotectedMemSize(nvmlDevice_t device, unsigned long long sizeKiB) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetConfComputeUnprotectedMemSize
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetConfComputeUnprotectedMemSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5453
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemSetConfComputeGpusReadyState(unsigned int isAcceptingWork) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemSetConfComputeGpusReadyState
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemSetConfComputeGpusReadyState(unsigned int __pyx_v_isAcceptingWork) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlSystemSetConfComputeGpusReadyState", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5455
 * cdef nvmlReturn_t _nvmlSystemSetConfComputeGpusReadyState(unsigned int isAcceptingWork) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlSystemSetConfComputeGpusReadyState
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlSystemSetConfComputeGpusReadyState == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5455, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5456
 *     global __nvmlSystemSetConfComputeGpusReadyState
 *     _check_or_init_nvml()
 *     if __nvmlSystemSetConfComputeGpusReadyState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemSetConfComputeGpusReadyState is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemSetConfComputeGpusReadyState == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5457
 *     _check_or_init_nvml()
 *     if __nvmlSystemSetConfComputeGpusReadyState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemSetConfComputeGpusReadyState is not found")
 *     return (<nvmlReturn_t (*)(unsigned int) noexcept nogil>__nvmlSystemSetConfComputeGpusReadyState)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5458
 *     if __nvmlSystemSetConfComputeGpusReadyState == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemSetConfComputeGpusReadyState is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(unsigned int) noexcept nogil>__nvmlSystemSetConfComputeGpusReadyState)(
 *         isAcceptingWork)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5458, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlSystemSetConfComput};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5458, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5458, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5457
 *     _check_or_init_nvml()
 *     if __nvmlSystemSetConfComputeGpusReadyState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemSetConfComputeGpusReadyState is not found")
 *     return (<nvmlReturn_t (*)(unsigned int) noexcept nogil>__nvmlSystemSetConfComputeGpusReadyState)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5456
 *     global __nvmlSystemSetConfComputeGpusReadyState
 *     _check_or_init_nvml()
 *     if __nvmlSystemSetConfComputeGpusReadyState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemSetConfComputeGpusReadyState is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5459
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemSetConfComputeGpusReadyState is not found")
 *     return (<nvmlReturn_t (*)(unsigned int) noexcept nogil>__nvmlSystemSetConfComputeGpusReadyState)(             # <<<<<<<<<<<<<<
 *         isAcceptingWork)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemSetConfComputeGpusReadyState)(__pyx_v_isAcceptingWork);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5453
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemSetConfComputeGpusReadyState(unsigned int isAcceptingWork) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemSetConfComputeGpusReadyState
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlSystemSetConfComputeGpusReadyState", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5463
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemSetConfComputeKeyRotationThresholdInfo(nvmlConfComputeSetKeyRotationThresholdInfo_t* pKeyRotationThrInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemSetConfComputeKeyRotationThresholdInfo
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemSetConfComputeKeyRotationThresholdInfo(nvmlConfComputeSetKeyRotationThresholdInfo_t *__pyx_v_pKeyRotationThrInfo) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlSystemSetConfComputeKeyRotationThresholdInfo", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5465
 * cdef nvmlReturn_t _nvmlSystemSetConfComputeKeyRotationThresholdInfo(nvmlConfComputeSetKeyRotationThresholdInfo_t* pKeyRotationThrInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlSystemSetConfComputeKeyRotationThresholdInfo
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlSystemSetConfComputeKeyRotationThresholdInfo == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5465, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5466
 *     global __nvmlSystemSetConfComputeKeyRotationThresholdInfo
 *     _check_or_init_nvml()
 *     if __nvmlSystemSetConfComputeKeyRotationThresholdInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemSetConfComputeKeyRotationThresholdInfo is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemSetConfComputeKeyRotationThresholdInfo == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5467
 *     _check_or_init_nvml()
 *     if __nvmlSystemSetConfComputeKeyRotationThresholdInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemSetConfComputeKeyRotationThresholdInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlConfComputeSetKeyRotationThresholdInfo_t*) noexcept nogil>__nvmlSystemSetConfComputeKeyRotationThresholdInfo)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5468
 *     if __nvmlSystemSetConfComputeKeyRotationThresholdInfo == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemSetConfComputeKeyRotationThresholdInfo is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlConfComputeSetKeyRotationThresholdInfo_t*) noexcept nogil>__nvmlSystemSetConfComputeKeyRotationThresholdInfo)(
 *         pKeyRotationThrInfo)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5468, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlSystemSetConfComput_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5468, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5468, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5467
 *     _check_or_init_nvml()
 *     if __nvmlSystemSetConfComputeKeyRotationThresholdInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemSetConfComputeKeyRotationThresholdInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlConfComputeSetKeyRotationThresholdInfo_t*) noexcept nogil>__nvmlSystemSetConfComputeKeyRotationThresholdInfo)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5466
 *     global __nvmlSystemSetConfComputeKeyRotationThresholdInfo
 *     _check_or_init_nvml()
 *     if __nvmlSystemSetConfComputeKeyRotationThresholdInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemSetConfComputeKeyRotationThresholdInfo is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5469
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemSetConfComputeKeyRotationThresholdInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlConfComputeSetKeyRotationThresholdInfo_t*) noexcept nogil>__nvmlSystemSetConfComputeKeyRotationThresholdInfo)(             # <<<<<<<<<<<<<<
 *         pKeyRotationThrInfo)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlConfComputeSetKeyRotationThresholdInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemSetConfComputeKeyRotationThresholdInfo)(__pyx_v_pKeyRotationThrInfo);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5463
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemSetConfComputeKeyRotationThresholdInfo(nvmlConfComputeSetKeyRotationThresholdInfo_t* pKeyRotationThrInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemSetConfComputeKeyRotationThresholdInfo
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlSystemSetConfComputeKeyRotationThresholdInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5473
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetConfComputeSettings(nvmlSystemConfComputeSettings_t* settings) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetConfComputeSettings
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetConfComputeSettings(nvmlSystemConfComputeSettings_t *__pyx_v_settings) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlSystemGetConfComputeSettings", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5475
 * cdef nvmlReturn_t _nvmlSystemGetConfComputeSettings(nvmlSystemConfComputeSettings_t* settings) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlSystemGetConfComputeSettings
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlSystemGetConfComputeSettings == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5475, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5476
 *     global __nvmlSystemGetConfComputeSettings
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetConfComputeSettings == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeSettings is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeSettings == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5477
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetConfComputeSettings == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeSettings is not found")
 *     return (<nvmlReturn_t (*)(nvmlSystemConfComputeSettings_t*) noexcept nogil>__nvmlSystemGetConfComputeSettings)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5478
 *     if __nvmlSystemGetConfComputeSettings == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeSettings is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlSystemConfComputeSettings_t*) noexcept nogil>__nvmlSystemGetConfComputeSettings)(
 *         settings)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5478, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlSystemGetConfComput_5};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5478, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5478, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5477
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetConfComputeSettings == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeSettings is not found")
 *     return (<nvmlReturn_t (*)(nvmlSystemConfComputeSettings_t*) noexcept nogil>__nvmlSystemGetConfComputeSettings)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5476
 *     global __nvmlSystemGetConfComputeSettings
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetConfComputeSettings == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeSettings is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5479
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetConfComputeSettings is not found")
 *     return (<nvmlReturn_t (*)(nvmlSystemConfComputeSettings_t*) noexcept nogil>__nvmlSystemGetConfComputeSettings)(             # <<<<<<<<<<<<<<
 *         settings)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlSystemConfComputeSettings_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeSettings)(__pyx_v_settings);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5473
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetConfComputeSettings(nvmlSystemConfComputeSettings_t* settings) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetConfComputeSettings
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlSystemGetConfComputeSettings", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5483
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGspFirmwareVersion(nvmlDevice_t device, char* version) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGspFirmwareVersion
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGspFirmwareVersion(nvmlDevice_t __pyx_v_device, char *__pyx_v_version) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetGspFirmwareVersion", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5485
 * cdef nvmlReturn_t _nvmlDeviceGetGspFirmwareVersion(nvmlDevice_t device, char* version) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetGspFirmwareVersion
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetGspFirmwareVersion == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5485, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5486
 *     global __nvmlDeviceGetGspFirmwareVersion
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGspFirmwareVersion == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGspFirmwareVersion is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGspFirmwareVersion == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5487
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGspFirmwareVersion == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGspFirmwareVersion is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*) noexcept nogil>__nvmlDeviceGetGspFirmwareVersion)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5488
 *     if __nvmlDeviceGetGspFirmwareVersion == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGspFirmwareVersion is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*) noexcept nogil>__nvmlDeviceGetGspFirmwareVersion)(
 *         device, version)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5488, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetGspFirmwar};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5488, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5488, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5487
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGspFirmwareVersion == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGspFirmwareVersion is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*) noexcept nogil>__nvmlDeviceGetGspFirmwareVersion)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5486
 *     global __nvmlDeviceGetGspFirmwareVersion
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGspFirmwareVersion == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGspFirmwareVersion is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5489
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGspFirmwareVersion is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*) noexcept nogil>__nvmlDeviceGetGspFirmwareVersion)(             # <<<<<<<<<<<<<<
 *         device, version)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, char *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGspFirmwareVersion)(__pyx_v_device, __pyx_v_version);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5483
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGspFirmwareVersion(nvmlDevice_t device, char* version) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGspFirmwareVersion
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetGspFirmwareVersion", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5493
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGspFirmwareMode(nvmlDevice_t device, unsigned int* isEnabled, unsigned int* defaultMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGspFirmwareMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGspFirmwareMode(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_isEnabled, unsigned int *__pyx_v_defaultMode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetGspFirmwareMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5495
 * cdef nvmlReturn_t _nvmlDeviceGetGspFirmwareMode(nvmlDevice_t device, unsigned int* isEnabled, unsigned int* defaultMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetGspFirmwareMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetGspFirmwareMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5495, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5496
 *     global __nvmlDeviceGetGspFirmwareMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGspFirmwareMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGspFirmwareMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGspFirmwareMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5497
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGspFirmwareMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGspFirmwareMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetGspFirmwareMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5498
 *     if __nvmlDeviceGetGspFirmwareMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGspFirmwareMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetGspFirmwareMode)(
 *         device, isEnabled, defaultMode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5498, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetGspFirmwar_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5498, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5498, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5497
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGspFirmwareMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGspFirmwareMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetGspFirmwareMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5496
 *     global __nvmlDeviceGetGspFirmwareMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGspFirmwareMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGspFirmwareMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5499
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGspFirmwareMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetGspFirmwareMode)(             # <<<<<<<<<<<<<<
 *         device, isEnabled, defaultMode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGspFirmwareMode)(__pyx_v_device, __pyx_v_isEnabled, __pyx_v_defaultMode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5493
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGspFirmwareMode(nvmlDevice_t device, unsigned int* isEnabled, unsigned int* defaultMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGspFirmwareMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetGspFirmwareMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5503
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetSramEccErrorStatus(nvmlDevice_t device, nvmlEccSramErrorStatus_t* status) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetSramEccErrorStatus
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetSramEccErrorStatus(nvmlDevice_t __pyx_v_device, nvmlEccSramErrorStatus_t *__pyx_v_status) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetSramEccErrorStatus", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5505
 * cdef nvmlReturn_t _nvmlDeviceGetSramEccErrorStatus(nvmlDevice_t device, nvmlEccSramErrorStatus_t* status) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetSramEccErrorStatus
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetSramEccErrorStatus == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5505, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5506
 *     global __nvmlDeviceGetSramEccErrorStatus
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSramEccErrorStatus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSramEccErrorStatus is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSramEccErrorStatus == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5507
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSramEccErrorStatus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetSramEccErrorStatus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEccSramErrorStatus_t*) noexcept nogil>__nvmlDeviceGetSramEccErrorStatus)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5508
 *     if __nvmlDeviceGetSramEccErrorStatus == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSramEccErrorStatus is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEccSramErrorStatus_t*) noexcept nogil>__nvmlDeviceGetSramEccErrorStatus)(
 *         device, status)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5508, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetSramEccErr};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5508, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5508, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5507
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSramEccErrorStatus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetSramEccErrorStatus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEccSramErrorStatus_t*) noexcept nogil>__nvmlDeviceGetSramEccErrorStatus)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5506
 *     global __nvmlDeviceGetSramEccErrorStatus
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSramEccErrorStatus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSramEccErrorStatus is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5509
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSramEccErrorStatus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEccSramErrorStatus_t*) noexcept nogil>__nvmlDeviceGetSramEccErrorStatus)(             # <<<<<<<<<<<<<<
 *         device, status)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlEccSramErrorStatus_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSramEccErrorStatus)(__pyx_v_device, __pyx_v_status);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5503
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetSramEccErrorStatus(nvmlDevice_t device, nvmlEccSramErrorStatus_t* status) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetSramEccErrorStatus
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetSramEccErrorStatus", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5513
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetAccountingMode(nvmlDevice_t device, nvmlEnableState_t* mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetAccountingMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetAccountingMode(nvmlDevice_t __pyx_v_device, nvmlEnableState_t *__pyx_v_mode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetAccountingMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5515
 * cdef nvmlReturn_t _nvmlDeviceGetAccountingMode(nvmlDevice_t device, nvmlEnableState_t* mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetAccountingMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetAccountingMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5515, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5516
 *     global __nvmlDeviceGetAccountingMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAccountingMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAccountingMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5517
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAccountingMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetAccountingMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetAccountingMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5518
 *     if __nvmlDeviceGetAccountingMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAccountingMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetAccountingMode)(
 *         device, mode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5518, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetAccounting};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5518, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5518, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5517
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAccountingMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetAccountingMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetAccountingMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5516
 *     global __nvmlDeviceGetAccountingMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAccountingMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAccountingMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5519
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAccountingMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetAccountingMode)(             # <<<<<<<<<<<<<<
 *         device, mode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingMode)(__pyx_v_device, __pyx_v_mode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5513
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetAccountingMode(nvmlDevice_t device, nvmlEnableState_t* mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetAccountingMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetAccountingMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5523
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetAccountingStats(nvmlDevice_t device, unsigned int pid, nvmlAccountingStats_t* stats) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetAccountingStats
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetAccountingStats(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_pid, nvmlAccountingStats_t *__pyx_v_stats) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetAccountingStats", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5525
 * cdef nvmlReturn_t _nvmlDeviceGetAccountingStats(nvmlDevice_t device, unsigned int pid, nvmlAccountingStats_t* stats) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetAccountingStats
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetAccountingStats == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5525, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5526
 *     global __nvmlDeviceGetAccountingStats
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAccountingStats == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAccountingStats is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingStats == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5527
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAccountingStats == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetAccountingStats is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlAccountingStats_t*) noexcept nogil>__nvmlDeviceGetAccountingStats)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5528
 *     if __nvmlDeviceGetAccountingStats == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAccountingStats is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlAccountingStats_t*) noexcept nogil>__nvmlDeviceGetAccountingStats)(
 *         device, pid, stats)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5528, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetAccounting_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5528, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5528, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5527
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAccountingStats == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetAccountingStats is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlAccountingStats_t*) noexcept nogil>__nvmlDeviceGetAccountingStats)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5526
 *     global __nvmlDeviceGetAccountingStats
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAccountingStats == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAccountingStats is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5529
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAccountingStats is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlAccountingStats_t*) noexcept nogil>__nvmlDeviceGetAccountingStats)(             # <<<<<<<<<<<<<<
 *         device, pid, stats)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlAccountingStats_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingStats)(__pyx_v_device, __pyx_v_pid, __pyx_v_stats);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5523
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetAccountingStats(nvmlDevice_t device, unsigned int pid, nvmlAccountingStats_t* stats) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetAccountingStats
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetAccountingStats", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5533
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetAccountingPids(nvmlDevice_t device, unsigned int* count, unsigned int* pids) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetAccountingPids
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetAccountingPids(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_count, unsigned int *__pyx_v_pids) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetAccountingPids", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5535
 * cdef nvmlReturn_t _nvmlDeviceGetAccountingPids(nvmlDevice_t device, unsigned int* count, unsigned int* pids) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetAccountingPids
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetAccountingPids == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5535, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5536
 *     global __nvmlDeviceGetAccountingPids
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAccountingPids == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAccountingPids is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingPids == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5537
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAccountingPids == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetAccountingPids is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetAccountingPids)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5538
 *     if __nvmlDeviceGetAccountingPids == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAccountingPids is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetAccountingPids)(
 *         device, count, pids)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5538, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetAccounting_3};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5538, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5538, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5537
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAccountingPids == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetAccountingPids is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetAccountingPids)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5536
 *     global __nvmlDeviceGetAccountingPids
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAccountingPids == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAccountingPids is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5539
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAccountingPids is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetAccountingPids)(             # <<<<<<<<<<<<<<
 *         device, count, pids)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingPids)(__pyx_v_device, __pyx_v_count, __pyx_v_pids);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5533
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetAccountingPids(nvmlDevice_t device, unsigned int* count, unsigned int* pids) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetAccountingPids
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetAccountingPids", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5543
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetAccountingBufferSize(nvmlDevice_t device, unsigned int* bufferSize) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetAccountingBufferSize
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetAccountingBufferSize(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_bufferSize) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetAccountingBufferSize", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5545
 * cdef nvmlReturn_t _nvmlDeviceGetAccountingBufferSize(nvmlDevice_t device, unsigned int* bufferSize) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetAccountingBufferSize
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetAccountingBufferSize == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5545, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5546
 *     global __nvmlDeviceGetAccountingBufferSize
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAccountingBufferSize == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAccountingBufferSize is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingBufferSize == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5547
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAccountingBufferSize == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetAccountingBufferSize is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetAccountingBufferSize)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5548
 *     if __nvmlDeviceGetAccountingBufferSize == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAccountingBufferSize is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetAccountingBufferSize)(
 *         device, bufferSize)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5548, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetAccounting_4};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5548, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5548, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5547
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAccountingBufferSize == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetAccountingBufferSize is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetAccountingBufferSize)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5546
 *     global __nvmlDeviceGetAccountingBufferSize
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAccountingBufferSize == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAccountingBufferSize is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5549
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAccountingBufferSize is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetAccountingBufferSize)(             # <<<<<<<<<<<<<<
 *         device, bufferSize)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingBufferSize)(__pyx_v_device, __pyx_v_bufferSize);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5543
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetAccountingBufferSize(nvmlDevice_t device, unsigned int* bufferSize) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetAccountingBufferSize
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetAccountingBufferSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5553
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetRetiredPages(nvmlDevice_t device, nvmlPageRetirementCause_t cause, unsigned int* pageCount, unsigned long long* addresses) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetRetiredPages
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetRetiredPages(nvmlDevice_t __pyx_v_device, nvmlPageRetirementCause_t __pyx_v_cause, unsigned int *__pyx_v_pageCount, unsigned PY_LONG_LONG *__pyx_v_addresses) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetRetiredPages", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5555
 * cdef nvmlReturn_t _nvmlDeviceGetRetiredPages(nvmlDevice_t device, nvmlPageRetirementCause_t cause, unsigned int* pageCount, unsigned long long* addresses) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetRetiredPages
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetRetiredPages == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5555, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5556
 *     global __nvmlDeviceGetRetiredPages
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRetiredPages == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRetiredPages is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRetiredPages == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5557
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRetiredPages == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetRetiredPages is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPageRetirementCause_t, unsigned int*, unsigned long long*) noexcept nogil>__nvmlDeviceGetRetiredPages)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5558
 *     if __nvmlDeviceGetRetiredPages == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRetiredPages is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPageRetirementCause_t, unsigned int*, unsigned long long*) noexcept nogil>__nvmlDeviceGetRetiredPages)(
 *         device, cause, pageCount, addresses)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5558, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetRetiredPag};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5558, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5558, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5557
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRetiredPages == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetRetiredPages is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPageRetirementCause_t, unsigned int*, unsigned long long*) noexcept nogil>__nvmlDeviceGetRetiredPages)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5556
 *     global __nvmlDeviceGetRetiredPages
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRetiredPages == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRetiredPages is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5559
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRetiredPages is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPageRetirementCause_t, unsigned int*, unsigned long long*) noexcept nogil>__nvmlDeviceGetRetiredPages)(             # <<<<<<<<<<<<<<
 *         device, cause, pageCount, addresses)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlPageRetirementCause_t, unsigned int *, unsigned PY_LONG_LONG *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRetiredPages)(__pyx_v_device, __pyx_v_cause, __pyx_v_pageCount, __pyx_v_addresses);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5553
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetRetiredPages(nvmlDevice_t device, nvmlPageRetirementCause_t cause, unsigned int* pageCount, unsigned long long* addresses) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetRetiredPages
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetRetiredPages", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5563
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetRetiredPages_v2(nvmlDevice_t device, nvmlPageRetirementCause_t cause, unsigned int* pageCount, unsigned long long* addresses, unsigned long long* timestamps) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetRetiredPages_v2
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetRetiredPages_v2(nvmlDevice_t __pyx_v_device, nvmlPageRetirementCause_t __pyx_v_cause, unsigned int *__pyx_v_pageCount, unsigned PY_LONG_LONG *__pyx_v_addresses, unsigned PY_LONG_LONG *__pyx_v_timestamps) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetRetiredPages_v2", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5565
 * cdef nvmlReturn_t _nvmlDeviceGetRetiredPages_v2(nvmlDevice_t device, nvmlPageRetirementCause_t cause, unsigned int* pageCount, unsigned long long* addresses, unsigned long long* timestamps) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetRetiredPages_v2
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetRetiredPages_v2 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5565, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5566
 *     global __nvmlDeviceGetRetiredPages_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRetiredPages_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRetiredPages_v2 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRetiredPages_v2 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5567
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRetiredPages_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetRetiredPages_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPageRetirementCause_t, unsigned int*, unsigned long long*, unsigned long long*) noexcept nogil>__nvmlDeviceGetRetiredPages_v2)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5568
 *     if __nvmlDeviceGetRetiredPages_v2 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRetiredPages_v2 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPageRetirementCause_t, unsigned int*, unsigned long long*, unsigned long long*) noexcept nogil>__nvmlDeviceGetRetiredPages_v2)(
 *         device, cause, pageCount, addresses, timestamps)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5568, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetRetiredPag_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5568, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5568, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5567
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRetiredPages_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetRetiredPages_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPageRetirementCause_t, unsigned int*, unsigned long long*, unsigned long long*) noexcept nogil>__nvmlDeviceGetRetiredPages_v2)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5566
 *     global __nvmlDeviceGetRetiredPages_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRetiredPages_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRetiredPages_v2 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5569
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRetiredPages_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPageRetirementCause_t, unsigned int*, unsigned long long*, unsigned long long*) noexcept nogil>__nvmlDeviceGetRetiredPages_v2)(             # <<<<<<<<<<<<<<
 *         device, cause, pageCount, addresses, timestamps)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlPageRetirementCause_t, unsigned int *, unsigned PY_LONG_LONG *, unsigned PY_LONG_LONG *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRetiredPages_v2)(__pyx_v_device, __pyx_v_cause, __pyx_v_pageCount, __pyx_v_addresses, __pyx_v_timestamps);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5563
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetRetiredPages_v2(nvmlDevice_t device, nvmlPageRetirementCause_t cause, unsigned int* pageCount, unsigned long long* addresses, unsigned long long* timestamps) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetRetiredPages_v2
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetRetiredPages_v2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5573
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetRetiredPagesPendingStatus(nvmlDevice_t device, nvmlEnableState_t* isPending) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetRetiredPagesPendingStatus
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetRetiredPagesPendingStatus(nvmlDevice_t __pyx_v_device, nvmlEnableState_t *__pyx_v_isPending) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetRetiredPagesPendingStatus", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5575
 * cdef nvmlReturn_t _nvmlDeviceGetRetiredPagesPendingStatus(nvmlDevice_t device, nvmlEnableState_t* isPending) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetRetiredPagesPendingStatus
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetRetiredPagesPendingStatus == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5575, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5576
 *     global __nvmlDeviceGetRetiredPagesPendingStatus
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRetiredPagesPendingStatus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRetiredPagesPendingStatus is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRetiredPagesPendingStatus == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5577
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRetiredPagesPendingStatus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetRetiredPagesPendingStatus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetRetiredPagesPendingStatus)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5578
 *     if __nvmlDeviceGetRetiredPagesPendingStatus == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRetiredPagesPendingStatus is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetRetiredPagesPendingStatus)(
 *         device, isPending)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5578, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetRetiredPag_3};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5578, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5578, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5577
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRetiredPagesPendingStatus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetRetiredPagesPendingStatus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetRetiredPagesPendingStatus)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5576
 *     global __nvmlDeviceGetRetiredPagesPendingStatus
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRetiredPagesPendingStatus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRetiredPagesPendingStatus is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5579
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRetiredPagesPendingStatus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetRetiredPagesPendingStatus)(             # <<<<<<<<<<<<<<
 *         device, isPending)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRetiredPagesPendingStatus)(__pyx_v_device, __pyx_v_isPending);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5573
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetRetiredPagesPendingStatus(nvmlDevice_t device, nvmlEnableState_t* isPending) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetRetiredPagesPendingStatus
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetRetiredPagesPendingStatus", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5583
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetRemappedRows(nvmlDevice_t device, unsigned int* corrRows, unsigned int* uncRows, unsigned int* isPending, unsigned int* failureOccurred) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetRemappedRows
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetRemappedRows(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_corrRows, unsigned int *__pyx_v_uncRows, unsigned int *__pyx_v_isPending, unsigned int *__pyx_v_failureOccurred) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetRemappedRows", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5585
 * cdef nvmlReturn_t _nvmlDeviceGetRemappedRows(nvmlDevice_t device, unsigned int* corrRows, unsigned int* uncRows, unsigned int* isPending, unsigned int* failureOccurred) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetRemappedRows
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetRemappedRows == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5585, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5586
 *     global __nvmlDeviceGetRemappedRows
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRemappedRows == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRemappedRows is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRemappedRows == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5587
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRemappedRows == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetRemappedRows is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetRemappedRows)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5588
 *     if __nvmlDeviceGetRemappedRows == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRemappedRows is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetRemappedRows)(
 *         device, corrRows, uncRows, isPending, failureOccurred)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5588, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetRemappedRo};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5588, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5588, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5587
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRemappedRows == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetRemappedRows is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetRemappedRows)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5586
 *     global __nvmlDeviceGetRemappedRows
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRemappedRows == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRemappedRows is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5589
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRemappedRows is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetRemappedRows)(             # <<<<<<<<<<<<<<
 *         device, corrRows, uncRows, isPending, failureOccurred)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *, unsigned int *, unsigned int *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRemappedRows)(__pyx_v_device, __pyx_v_corrRows, __pyx_v_uncRows, __pyx_v_isPending, __pyx_v_failureOccurred);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5583
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetRemappedRows(nvmlDevice_t device, unsigned int* corrRows, unsigned int* uncRows, unsigned int* isPending, unsigned int* failureOccurred) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetRemappedRows
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetRemappedRows", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5593
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetRowRemapperHistogram(nvmlDevice_t device, nvmlRowRemapperHistogramValues_t* values) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetRowRemapperHistogram
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetRowRemapperHistogram(nvmlDevice_t __pyx_v_device, nvmlRowRemapperHistogramValues_t *__pyx_v_values) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetRowRemapperHistogram", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5595
 * cdef nvmlReturn_t _nvmlDeviceGetRowRemapperHistogram(nvmlDevice_t device, nvmlRowRemapperHistogramValues_t* values) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetRowRemapperHistogram
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetRowRemapperHistogram == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5595, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5596
 *     global __nvmlDeviceGetRowRemapperHistogram
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRowRemapperHistogram == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRowRemapperHistogram is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRowRemapperHistogram == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5597
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRowRemapperHistogram == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetRowRemapperHistogram is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlRowRemapperHistogramValues_t*) noexcept nogil>__nvmlDeviceGetRowRemapperHistogram)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5598
 *     if __nvmlDeviceGetRowRemapperHistogram == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRowRemapperHistogram is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlRowRemapperHistogramValues_t*) noexcept nogil>__nvmlDeviceGetRowRemapperHistogram)(
 *         device, values)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5598, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetRowRemappe};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5598, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5598, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5597
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRowRemapperHistogram == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetRowRemapperHistogram is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlRowRemapperHistogramValues_t*) noexcept nogil>__nvmlDeviceGetRowRemapperHistogram)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5596
 *     global __nvmlDeviceGetRowRemapperHistogram
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRowRemapperHistogram == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRowRemapperHistogram is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5599
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRowRemapperHistogram is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlRowRemapperHistogramValues_t*) noexcept nogil>__nvmlDeviceGetRowRemapperHistogram)(             # <<<<<<<<<<<<<<
 *         device, values)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlRowRemapperHistogramValues_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRowRemapperHistogram)(__pyx_v_device, __pyx_v_values);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5593
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetRowRemapperHistogram(nvmlDevice_t device, nvmlRowRemapperHistogramValues_t* values) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetRowRemapperHistogram
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetRowRemapperHistogram", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5603
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetArchitecture(nvmlDevice_t device, nvmlDeviceArchitecture_t* arch) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetArchitecture
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetArchitecture(nvmlDevice_t __pyx_v_device, nvmlDeviceArchitecture_t *__pyx_v_arch) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetArchitecture", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5605
 * cdef nvmlReturn_t _nvmlDeviceGetArchitecture(nvmlDevice_t device, nvmlDeviceArchitecture_t* arch) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetArchitecture
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetArchitecture == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5605, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5606
 *     global __nvmlDeviceGetArchitecture
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetArchitecture == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetArchitecture is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetArchitecture == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5607
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetArchitecture == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetArchitecture is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceArchitecture_t*) noexcept nogil>__nvmlDeviceGetArchitecture)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5608
 *     if __nvmlDeviceGetArchitecture == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetArchitecture is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceArchitecture_t*) noexcept nogil>__nvmlDeviceGetArchitecture)(
 *         device, arch)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5608, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetArchitectu};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5608, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5608, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5607
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetArchitecture == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetArchitecture is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceArchitecture_t*) noexcept nogil>__nvmlDeviceGetArchitecture)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5606
 *     global __nvmlDeviceGetArchitecture
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetArchitecture == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetArchitecture is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5609
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetArchitecture is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceArchitecture_t*) noexcept nogil>__nvmlDeviceGetArchitecture)(             # <<<<<<<<<<<<<<
 *         device, arch)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceArchitecture_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetArchitecture)(__pyx_v_device, __pyx_v_arch);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5603
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetArchitecture(nvmlDevice_t device, nvmlDeviceArchitecture_t* arch) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetArchitecture
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetArchitecture", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5613
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetClkMonStatus(nvmlDevice_t device, nvmlClkMonStatus_t* status) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetClkMonStatus
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetClkMonStatus(nvmlDevice_t __pyx_v_device, nvmlClkMonStatus_t *__pyx_v_status) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetClkMonStatus", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5615
 * cdef nvmlReturn_t _nvmlDeviceGetClkMonStatus(nvmlDevice_t device, nvmlClkMonStatus_t* status) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetClkMonStatus
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetClkMonStatus == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5615, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5616
 *     global __nvmlDeviceGetClkMonStatus
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetClkMonStatus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetClkMonStatus is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClkMonStatus == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5617
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetClkMonStatus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetClkMonStatus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClkMonStatus_t*) noexcept nogil>__nvmlDeviceGetClkMonStatus)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5618
 *     if __nvmlDeviceGetClkMonStatus == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetClkMonStatus is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClkMonStatus_t*) noexcept nogil>__nvmlDeviceGetClkMonStatus)(
 *         device, status)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5618, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetClkMonStat};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5618, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5618, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5617
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetClkMonStatus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetClkMonStatus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClkMonStatus_t*) noexcept nogil>__nvmlDeviceGetClkMonStatus)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5616
 *     global __nvmlDeviceGetClkMonStatus
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetClkMonStatus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetClkMonStatus is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5619
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetClkMonStatus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlClkMonStatus_t*) noexcept nogil>__nvmlDeviceGetClkMonStatus)(             # <<<<<<<<<<<<<<
 *         device, status)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlClkMonStatus_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClkMonStatus)(__pyx_v_device, __pyx_v_status);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5613
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetClkMonStatus(nvmlDevice_t device, nvmlClkMonStatus_t* status) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetClkMonStatus
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetClkMonStatus", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5623
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetProcessUtilization(nvmlDevice_t device, nvmlProcessUtilizationSample_t* utilization, unsigned int* processSamplesCount, unsigned long long lastSeenTimeStamp) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetProcessUtilization
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetProcessUtilization(nvmlDevice_t __pyx_v_device, nvmlProcessUtilizationSample_t *__pyx_v_utilization, unsigned int *__pyx_v_processSamplesCount, unsigned PY_LONG_LONG __pyx_v_lastSeenTimeStamp) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetProcessUtilization", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5625
 * cdef nvmlReturn_t _nvmlDeviceGetProcessUtilization(nvmlDevice_t device, nvmlProcessUtilizationSample_t* utilization, unsigned int* processSamplesCount, unsigned long long lastSeenTimeStamp) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetProcessUtilization
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetProcessUtilization == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5625, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5626
 *     global __nvmlDeviceGetProcessUtilization
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetProcessUtilization == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetProcessUtilization is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetProcessUtilization == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5627
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetProcessUtilization == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetProcessUtilization is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlProcessUtilizationSample_t*, unsigned int*, unsigned long long) noexcept nogil>__nvmlDeviceGetProcessUtilization)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5628
 *     if __nvmlDeviceGetProcessUtilization == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetProcessUtilization is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlProcessUtilizationSample_t*, unsigned int*, unsigned long long) noexcept nogil>__nvmlDeviceGetProcessUtilization)(
 *         device, utilization, processSamplesCount, lastSeenTimeStamp)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5628, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetProcessUti};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5628, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5628, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5627
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetProcessUtilization == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetProcessUtilization is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlProcessUtilizationSample_t*, unsigned int*, unsigned long long) noexcept nogil>__nvmlDeviceGetProcessUtilization)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5626
 *     global __nvmlDeviceGetProcessUtilization
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetProcessUtilization == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetProcessUtilization is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5629
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetProcessUtilization is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlProcessUtilizationSample_t*, unsigned int*, unsigned long long) noexcept nogil>__nvmlDeviceGetProcessUtilization)(             # <<<<<<<<<<<<<<
 *         device, utilization, processSamplesCount, lastSeenTimeStamp)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlProcessUtilizationSample_t *, unsigned int *, unsigned PY_LONG_LONG))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetProcessUtilization)(__pyx_v_device, __pyx_v_utilization, __pyx_v_processSamplesCount, __pyx_v_lastSeenTimeStamp);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5623
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetProcessUtilization(nvmlDevice_t device, nvmlProcessUtilizationSample_t* utilization, unsigned int* processSamplesCount, unsigned long long lastSeenTimeStamp) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetProcessUtilization
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetProcessUtilization", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5633
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetProcessesUtilizationInfo(nvmlDevice_t device, nvmlProcessesUtilizationInfo_t* procesesUtilInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetProcessesUtilizationInfo
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetProcessesUtilizationInfo(nvmlDevice_t __pyx_v_device, nvmlProcessesUtilizationInfo_t *__pyx_v_procesesUtilInfo) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetProcessesUtilizationInfo", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5635
 * cdef nvmlReturn_t _nvmlDeviceGetProcessesUtilizationInfo(nvmlDevice_t device, nvmlProcessesUtilizationInfo_t* procesesUtilInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetProcessesUtilizationInfo
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetProcessesUtilizationInfo == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5635, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5636
 *     global __nvmlDeviceGetProcessesUtilizationInfo
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetProcessesUtilizationInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetProcessesUtilizationInfo is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetProcessesUtilizationInfo == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5637
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetProcessesUtilizationInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetProcessesUtilizationInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlProcessesUtilizationInfo_t*) noexcept nogil>__nvmlDeviceGetProcessesUtilizationInfo)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5638
 *     if __nvmlDeviceGetProcessesUtilizationInfo == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetProcessesUtilizationInfo is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlProcessesUtilizationInfo_t*) noexcept nogil>__nvmlDeviceGetProcessesUtilizationInfo)(
 *         device, procesesUtilInfo)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5638, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetProcessesU};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5638, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5638, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5637
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetProcessesUtilizationInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetProcessesUtilizationInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlProcessesUtilizationInfo_t*) noexcept nogil>__nvmlDeviceGetProcessesUtilizationInfo)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5636
 *     global __nvmlDeviceGetProcessesUtilizationInfo
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetProcessesUtilizationInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetProcessesUtilizationInfo is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5639
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetProcessesUtilizationInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlProcessesUtilizationInfo_t*) noexcept nogil>__nvmlDeviceGetProcessesUtilizationInfo)(             # <<<<<<<<<<<<<<
 *         device, procesesUtilInfo)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlProcessesUtilizationInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetProcessesUtilizationInfo)(__pyx_v_device, __pyx_v_procesesUtilInfo);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5633
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetProcessesUtilizationInfo(nvmlDevice_t device, nvmlProcessesUtilizationInfo_t* procesesUtilInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetProcessesUtilizationInfo
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetProcessesUtilizationInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5643
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPlatformInfo(nvmlDevice_t device, nvmlPlatformInfo_t* platformInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPlatformInfo
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPlatformInfo(nvmlDevice_t __pyx_v_device, nvmlPlatformInfo_t *__pyx_v_platformInfo) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetPlatformInfo", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5645
 * cdef nvmlReturn_t _nvmlDeviceGetPlatformInfo(nvmlDevice_t device, nvmlPlatformInfo_t* platformInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetPlatformInfo
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetPlatformInfo == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5645, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5646
 *     global __nvmlDeviceGetPlatformInfo
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPlatformInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPlatformInfo is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPlatformInfo == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5647
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPlatformInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPlatformInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPlatformInfo_t*) noexcept nogil>__nvmlDeviceGetPlatformInfo)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5648
 *     if __nvmlDeviceGetPlatformInfo == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPlatformInfo is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPlatformInfo_t*) noexcept nogil>__nvmlDeviceGetPlatformInfo)(
 *         device, platformInfo)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5648, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetPlatformIn};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5648, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5648, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5647
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPlatformInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPlatformInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPlatformInfo_t*) noexcept nogil>__nvmlDeviceGetPlatformInfo)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5646
 *     global __nvmlDeviceGetPlatformInfo
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPlatformInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPlatformInfo is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5649
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPlatformInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPlatformInfo_t*) noexcept nogil>__nvmlDeviceGetPlatformInfo)(             # <<<<<<<<<<<<<<
 *         device, platformInfo)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlPlatformInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPlatformInfo)(__pyx_v_device, __pyx_v_platformInfo);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5643
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPlatformInfo(nvmlDevice_t device, nvmlPlatformInfo_t* platformInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPlatformInfo
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetPlatformInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5653
 * 
 * 
 * cdef nvmlReturn_t _nvmlUnitSetLedState(nvmlUnit_t unit, nvmlLedColor_t color) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlUnitSetLedState
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlUnitSetLedState(nvmlUnit_t __pyx_v_unit, nvmlLedColor_t __pyx_v_color) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlUnitSetLedState", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5655
 * cdef nvmlReturn_t _nvmlUnitSetLedState(nvmlUnit_t unit, nvmlLedColor_t color) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlUnitSetLedState
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlUnitSetLedState == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5655, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5656
 *     global __nvmlUnitSetLedState
 *     _check_or_init_nvml()
 *     if __nvmlUnitSetLedState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitSetLedState is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitSetLedState == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5657
 *     _check_or_init_nvml()
 *     if __nvmlUnitSetLedState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlUnitSetLedState is not found")
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, nvmlLedColor_t) noexcept nogil>__nvmlUnitSetLedState)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5658
 *     if __nvmlUnitSetLedState == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitSetLedState is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, nvmlLedColor_t) noexcept nogil>__nvmlUnitSetLedState)(
 *         unit, color)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5658, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlUnitSetLedState_is};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5658, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5658, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5657
 *     _check_or_init_nvml()
 *     if __nvmlUnitSetLedState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlUnitSetLedState is not found")
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, nvmlLedColor_t) noexcept nogil>__nvmlUnitSetLedState)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5656
 *     global __nvmlUnitSetLedState
 *     _check_or_init_nvml()
 *     if __nvmlUnitSetLedState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitSetLedState is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5659
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlUnitSetLedState is not found")
 *     return (<nvmlReturn_t (*)(nvmlUnit_t, nvmlLedColor_t) noexcept nogil>__nvmlUnitSetLedState)(             # <<<<<<<<<<<<<<
 *         unit, color)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlUnit_t, nvmlLedColor_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitSetLedState)(__pyx_v_unit, __pyx_v_color);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5653
 * 
 * 
 * cdef nvmlReturn_t _nvmlUnitSetLedState(nvmlUnit_t unit, nvmlLedColor_t color) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlUnitSetLedState
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlUnitSetLedState", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5663
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetPersistenceMode(nvmlDevice_t device, nvmlEnableState_t mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetPersistenceMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetPersistenceMode(nvmlDevice_t __pyx_v_device, nvmlEnableState_t __pyx_v_mode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetPersistenceMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5665
 * cdef nvmlReturn_t _nvmlDeviceSetPersistenceMode(nvmlDevice_t device, nvmlEnableState_t mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetPersistenceMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetPersistenceMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5665, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5666
 *     global __nvmlDeviceSetPersistenceMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetPersistenceMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetPersistenceMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPersistenceMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5667
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetPersistenceMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetPersistenceMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t) noexcept nogil>__nvmlDeviceSetPersistenceMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5668
 *     if __nvmlDeviceSetPersistenceMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetPersistenceMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t) noexcept nogil>__nvmlDeviceSetPersistenceMode)(
 *         device, mode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5668, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetPersistenc};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5668, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5668, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5667
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetPersistenceMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetPersistenceMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t) noexcept nogil>__nvmlDeviceSetPersistenceMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5666
 *     global __nvmlDeviceSetPersistenceMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetPersistenceMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetPersistenceMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5669
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetPersistenceMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t) noexcept nogil>__nvmlDeviceSetPersistenceMode)(             # <<<<<<<<<<<<<<
 *         device, mode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPersistenceMode)(__pyx_v_device, __pyx_v_mode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5663
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetPersistenceMode(nvmlDevice_t device, nvmlEnableState_t mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetPersistenceMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetPersistenceMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5673
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetComputeMode(nvmlDevice_t device, nvmlComputeMode_t mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetComputeMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetComputeMode(nvmlDevice_t __pyx_v_device, nvmlComputeMode_t __pyx_v_mode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetComputeMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5675
 * cdef nvmlReturn_t _nvmlDeviceSetComputeMode(nvmlDevice_t device, nvmlComputeMode_t mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetComputeMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetComputeMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5675, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5676
 *     global __nvmlDeviceSetComputeMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetComputeMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetComputeMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetComputeMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5677
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetComputeMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetComputeMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlComputeMode_t) noexcept nogil>__nvmlDeviceSetComputeMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5678
 *     if __nvmlDeviceSetComputeMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetComputeMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlComputeMode_t) noexcept nogil>__nvmlDeviceSetComputeMode)(
 *         device, mode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5678, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetComputeMod};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5678, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5678, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5677
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetComputeMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetComputeMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlComputeMode_t) noexcept nogil>__nvmlDeviceSetComputeMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5676
 *     global __nvmlDeviceSetComputeMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetComputeMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetComputeMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5679
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetComputeMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlComputeMode_t) noexcept nogil>__nvmlDeviceSetComputeMode)(             # <<<<<<<<<<<<<<
 *         device, mode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlComputeMode_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetComputeMode)(__pyx_v_device, __pyx_v_mode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5673
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetComputeMode(nvmlDevice_t device, nvmlComputeMode_t mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetComputeMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetComputeMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5683
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetEccMode(nvmlDevice_t device, nvmlEnableState_t ecc) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetEccMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetEccMode(nvmlDevice_t __pyx_v_device, nvmlEnableState_t __pyx_v_ecc) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetEccMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5685
 * cdef nvmlReturn_t _nvmlDeviceSetEccMode(nvmlDevice_t device, nvmlEnableState_t ecc) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetEccMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetEccMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5685, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5686
 *     global __nvmlDeviceSetEccMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetEccMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetEccMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetEccMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5687
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetEccMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetEccMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t) noexcept nogil>__nvmlDeviceSetEccMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5688
 *     if __nvmlDeviceSetEccMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetEccMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t) noexcept nogil>__nvmlDeviceSetEccMode)(
 *         device, ecc)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5688, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetEccMode_is};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5688, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5688, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5687
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetEccMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetEccMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t) noexcept nogil>__nvmlDeviceSetEccMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5686
 *     global __nvmlDeviceSetEccMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetEccMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetEccMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5689
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetEccMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t) noexcept nogil>__nvmlDeviceSetEccMode)(             # <<<<<<<<<<<<<<
 *         device, ecc)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetEccMode)(__pyx_v_device, __pyx_v_ecc);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5683
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetEccMode(nvmlDevice_t device, nvmlEnableState_t ecc) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetEccMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetEccMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5693
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceClearEccErrorCounts(nvmlDevice_t device, nvmlEccCounterType_t counterType) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceClearEccErrorCounts
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceClearEccErrorCounts(nvmlDevice_t __pyx_v_device, nvmlEccCounterType_t __pyx_v_counterType) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceClearEccErrorCounts", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5695
 * cdef nvmlReturn_t _nvmlDeviceClearEccErrorCounts(nvmlDevice_t device, nvmlEccCounterType_t counterType) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceClearEccErrorCounts
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceClearEccErrorCounts == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5695, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5696
 *     global __nvmlDeviceClearEccErrorCounts
 *     _check_or_init_nvml()
 *     if __nvmlDeviceClearEccErrorCounts == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceClearEccErrorCounts is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearEccErrorCounts == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5697
 *     _check_or_init_nvml()
 *     if __nvmlDeviceClearEccErrorCounts == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceClearEccErrorCounts is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEccCounterType_t) noexcept nogil>__nvmlDeviceClearEccErrorCounts)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5698
 *     if __nvmlDeviceClearEccErrorCounts == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceClearEccErrorCounts is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEccCounterType_t) noexcept nogil>__nvmlDeviceClearEccErrorCounts)(
 *         device, counterType)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5698, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceClearEccError};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5698, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5698, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5697
 *     _check_or_init_nvml()
 *     if __nvmlDeviceClearEccErrorCounts == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceClearEccErrorCounts is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEccCounterType_t) noexcept nogil>__nvmlDeviceClearEccErrorCounts)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5696
 *     global __nvmlDeviceClearEccErrorCounts
 *     _check_or_init_nvml()
 *     if __nvmlDeviceClearEccErrorCounts == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceClearEccErrorCounts is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5699
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceClearEccErrorCounts is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEccCounterType_t) noexcept nogil>__nvmlDeviceClearEccErrorCounts)(             # <<<<<<<<<<<<<<
 *         device, counterType)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlEccCounterType_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearEccErrorCounts)(__pyx_v_device, __pyx_v_counterType);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5693
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceClearEccErrorCounts(nvmlDevice_t device, nvmlEccCounterType_t counterType) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceClearEccErrorCounts
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceClearEccErrorCounts", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5703
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetDriverModel(nvmlDevice_t device, nvmlDriverModel_t driverModel, unsigned int flags) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetDriverModel
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetDriverModel(nvmlDevice_t __pyx_v_device, nvmlDriverModel_t __pyx_v_driverModel, unsigned int __pyx_v_flags) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetDriverModel", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5705
 * cdef nvmlReturn_t _nvmlDeviceSetDriverModel(nvmlDevice_t device, nvmlDriverModel_t driverModel, unsigned int flags) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetDriverModel
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetDriverModel == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5705, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5706
 *     global __nvmlDeviceSetDriverModel
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetDriverModel == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetDriverModel is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDriverModel == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5707
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetDriverModel == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetDriverModel is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDriverModel_t, unsigned int) noexcept nogil>__nvmlDeviceSetDriverModel)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5708
 *     if __nvmlDeviceSetDriverModel == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetDriverModel is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDriverModel_t, unsigned int) noexcept nogil>__nvmlDeviceSetDriverModel)(
 *         device, driverModel, flags)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5708, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetDriverMode};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5708, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5708, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5707
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetDriverModel == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetDriverModel is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDriverModel_t, unsigned int) noexcept nogil>__nvmlDeviceSetDriverModel)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5706
 *     global __nvmlDeviceSetDriverModel
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetDriverModel == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetDriverModel is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5709
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetDriverModel is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDriverModel_t, unsigned int) noexcept nogil>__nvmlDeviceSetDriverModel)(             # <<<<<<<<<<<<<<
 *         device, driverModel, flags)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlDriverModel_t, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDriverModel)(__pyx_v_device, __pyx_v_driverModel, __pyx_v_flags);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5703
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetDriverModel(nvmlDevice_t device, nvmlDriverModel_t driverModel, unsigned int flags) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetDriverModel
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetDriverModel", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5713
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetGpuLockedClocks(nvmlDevice_t device, unsigned int minGpuClockMHz, unsigned int maxGpuClockMHz) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetGpuLockedClocks
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetGpuLockedClocks(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_minGpuClockMHz, unsigned int __pyx_v_maxGpuClockMHz) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetGpuLockedClocks", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5715
 * cdef nvmlReturn_t _nvmlDeviceSetGpuLockedClocks(nvmlDevice_t device, unsigned int minGpuClockMHz, unsigned int maxGpuClockMHz) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetGpuLockedClocks
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetGpuLockedClocks == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5715, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5716
 *     global __nvmlDeviceSetGpuLockedClocks
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetGpuLockedClocks == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetGpuLockedClocks is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetGpuLockedClocks == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5717
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetGpuLockedClocks == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetGpuLockedClocks is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int) noexcept nogil>__nvmlDeviceSetGpuLockedClocks)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5718
 *     if __nvmlDeviceSetGpuLockedClocks == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetGpuLockedClocks is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int) noexcept nogil>__nvmlDeviceSetGpuLockedClocks)(
 *         device, minGpuClockMHz, maxGpuClockMHz)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5718, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetGpuLockedC};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5718, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5718, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5717
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetGpuLockedClocks == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetGpuLockedClocks is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int) noexcept nogil>__nvmlDeviceSetGpuLockedClocks)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5716
 *     global __nvmlDeviceSetGpuLockedClocks
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetGpuLockedClocks == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetGpuLockedClocks is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5719
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetGpuLockedClocks is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int) noexcept nogil>__nvmlDeviceSetGpuLockedClocks)(             # <<<<<<<<<<<<<<
 *         device, minGpuClockMHz, maxGpuClockMHz)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetGpuLockedClocks)(__pyx_v_device, __pyx_v_minGpuClockMHz, __pyx_v_maxGpuClockMHz);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5713
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetGpuLockedClocks(nvmlDevice_t device, unsigned int minGpuClockMHz, unsigned int maxGpuClockMHz) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetGpuLockedClocks
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetGpuLockedClocks", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5723
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceResetGpuLockedClocks(nvmlDevice_t device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceResetGpuLockedClocks
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceResetGpuLockedClocks(nvmlDevice_t __pyx_v_device) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceResetGpuLockedClocks", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5725
 * cdef nvmlReturn_t _nvmlDeviceResetGpuLockedClocks(nvmlDevice_t device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceResetGpuLockedClocks
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceResetGpuLockedClocks == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5725, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5726
 *     global __nvmlDeviceResetGpuLockedClocks
 *     _check_or_init_nvml()
 *     if __nvmlDeviceResetGpuLockedClocks == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceResetGpuLockedClocks is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceResetGpuLockedClocks == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5727
 *     _check_or_init_nvml()
 *     if __nvmlDeviceResetGpuLockedClocks == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceResetGpuLockedClocks is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t) noexcept nogil>__nvmlDeviceResetGpuLockedClocks)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5728
 *     if __nvmlDeviceResetGpuLockedClocks == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceResetGpuLockedClocks is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t) noexcept nogil>__nvmlDeviceResetGpuLockedClocks)(
 *         device)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5728, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceResetGpuLocke};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5728, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5728, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5727
 *     _check_or_init_nvml()
 *     if __nvmlDeviceResetGpuLockedClocks == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceResetGpuLockedClocks is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t) noexcept nogil>__nvmlDeviceResetGpuLockedClocks)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5726
 *     global __nvmlDeviceResetGpuLockedClocks
 *     _check_or_init_nvml()
 *     if __nvmlDeviceResetGpuLockedClocks == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceResetGpuLockedClocks is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5729
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceResetGpuLockedClocks is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t) noexcept nogil>__nvmlDeviceResetGpuLockedClocks)(             # <<<<<<<<<<<<<<
 *         device)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceResetGpuLockedClocks)(__pyx_v_device);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5723
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceResetGpuLockedClocks(nvmlDevice_t device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceResetGpuLockedClocks
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceResetGpuLockedClocks", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5733
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetMemoryLockedClocks(nvmlDevice_t device, unsigned int minMemClockMHz, unsigned int maxMemClockMHz) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetMemoryLockedClocks
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetMemoryLockedClocks(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_minMemClockMHz, unsigned int __pyx_v_maxMemClockMHz) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetMemoryLockedClocks", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5735
 * cdef nvmlReturn_t _nvmlDeviceSetMemoryLockedClocks(nvmlDevice_t device, unsigned int minMemClockMHz, unsigned int maxMemClockMHz) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetMemoryLockedClocks
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetMemoryLockedClocks == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5735, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5736
 *     global __nvmlDeviceSetMemoryLockedClocks
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetMemoryLockedClocks == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetMemoryLockedClocks is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetMemoryLockedClocks == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5737
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetMemoryLockedClocks == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetMemoryLockedClocks is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int) noexcept nogil>__nvmlDeviceSetMemoryLockedClocks)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5738
 *     if __nvmlDeviceSetMemoryLockedClocks == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetMemoryLockedClocks is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int) noexcept nogil>__nvmlDeviceSetMemoryLockedClocks)(
 *         device, minMemClockMHz, maxMemClockMHz)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5738, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetMemoryLock};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5738, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5738, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5737
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetMemoryLockedClocks == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetMemoryLockedClocks is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int) noexcept nogil>__nvmlDeviceSetMemoryLockedClocks)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5736
 *     global __nvmlDeviceSetMemoryLockedClocks
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetMemoryLockedClocks == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetMemoryLockedClocks is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5739
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetMemoryLockedClocks is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int) noexcept nogil>__nvmlDeviceSetMemoryLockedClocks)(             # <<<<<<<<<<<<<<
 *         device, minMemClockMHz, maxMemClockMHz)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetMemoryLockedClocks)(__pyx_v_device, __pyx_v_minMemClockMHz, __pyx_v_maxMemClockMHz);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5733
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetMemoryLockedClocks(nvmlDevice_t device, unsigned int minMemClockMHz, unsigned int maxMemClockMHz) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetMemoryLockedClocks
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetMemoryLockedClocks", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5743
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceResetMemoryLockedClocks(nvmlDevice_t device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceResetMemoryLockedClocks
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceResetMemoryLockedClocks(nvmlDevice_t __pyx_v_device) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceResetMemoryLockedClocks", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5745
 * cdef nvmlReturn_t _nvmlDeviceResetMemoryLockedClocks(nvmlDevice_t device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceResetMemoryLockedClocks
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceResetMemoryLockedClocks == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5745, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5746
 *     global __nvmlDeviceResetMemoryLockedClocks
 *     _check_or_init_nvml()
 *     if __nvmlDeviceResetMemoryLockedClocks == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceResetMemoryLockedClocks is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceResetMemoryLockedClocks == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5747
 *     _check_or_init_nvml()
 *     if __nvmlDeviceResetMemoryLockedClocks == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceResetMemoryLockedClocks is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t) noexcept nogil>__nvmlDeviceResetMemoryLockedClocks)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5748
 *     if __nvmlDeviceResetMemoryLockedClocks == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceResetMemoryLockedClocks is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t) noexcept nogil>__nvmlDeviceResetMemoryLockedClocks)(
 *         device)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5748, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceResetMemoryLo};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5748, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5748, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5747
 *     _check_or_init_nvml()
 *     if __nvmlDeviceResetMemoryLockedClocks == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceResetMemoryLockedClocks is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t) noexcept nogil>__nvmlDeviceResetMemoryLockedClocks)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5746
 *     global __nvmlDeviceResetMemoryLockedClocks
 *     _check_or_init_nvml()
 *     if __nvmlDeviceResetMemoryLockedClocks == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceResetMemoryLockedClocks is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5749
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceResetMemoryLockedClocks is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t) noexcept nogil>__nvmlDeviceResetMemoryLockedClocks)(             # <<<<<<<<<<<<<<
 *         device)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceResetMemoryLockedClocks)(__pyx_v_device);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5743
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceResetMemoryLockedClocks(nvmlDevice_t device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceResetMemoryLockedClocks
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceResetMemoryLockedClocks", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5753
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetAutoBoostedClocksEnabled(nvmlDevice_t device, nvmlEnableState_t enabled) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetAutoBoostedClocksEnabled
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetAutoBoostedClocksEnabled(nvmlDevice_t __pyx_v_device, nvmlEnableState_t __pyx_v_enabled) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetAutoBoostedClocksEnabled", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5755
 * cdef nvmlReturn_t _nvmlDeviceSetAutoBoostedClocksEnabled(nvmlDevice_t device, nvmlEnableState_t enabled) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetAutoBoostedClocksEnabled
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetAutoBoostedClocksEnabled == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5755, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5756
 *     global __nvmlDeviceSetAutoBoostedClocksEnabled
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetAutoBoostedClocksEnabled == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetAutoBoostedClocksEnabled is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetAutoBoostedClocksEnabled == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5757
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetAutoBoostedClocksEnabled == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetAutoBoostedClocksEnabled is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t) noexcept nogil>__nvmlDeviceSetAutoBoostedClocksEnabled)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5758
 *     if __nvmlDeviceSetAutoBoostedClocksEnabled == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetAutoBoostedClocksEnabled is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t) noexcept nogil>__nvmlDeviceSetAutoBoostedClocksEnabled)(
 *         device, enabled)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5758, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetAutoBooste};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5758, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5758, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5757
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetAutoBoostedClocksEnabled == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetAutoBoostedClocksEnabled is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t) noexcept nogil>__nvmlDeviceSetAutoBoostedClocksEnabled)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5756
 *     global __nvmlDeviceSetAutoBoostedClocksEnabled
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetAutoBoostedClocksEnabled == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetAutoBoostedClocksEnabled is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5759
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetAutoBoostedClocksEnabled is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t) noexcept nogil>__nvmlDeviceSetAutoBoostedClocksEnabled)(             # <<<<<<<<<<<<<<
 *         device, enabled)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetAutoBoostedClocksEnabled)(__pyx_v_device, __pyx_v_enabled);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5753
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetAutoBoostedClocksEnabled(nvmlDevice_t device, nvmlEnableState_t enabled) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetAutoBoostedClocksEnabled
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetAutoBoostedClocksEnabled", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5763
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetDefaultAutoBoostedClocksEnabled(nvmlDevice_t device, nvmlEnableState_t enabled, unsigned int flags) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetDefaultAutoBoostedClocksEnabled
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetDefaultAutoBoostedClocksEnabled(nvmlDevice_t __pyx_v_device, nvmlEnableState_t __pyx_v_enabled, unsigned int __pyx_v_flags) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetDefaultAutoBoostedClocksEnabled", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5765
 * cdef nvmlReturn_t _nvmlDeviceSetDefaultAutoBoostedClocksEnabled(nvmlDevice_t device, nvmlEnableState_t enabled, unsigned int flags) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetDefaultAutoBoostedClocksEnabled
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetDefaultAutoBoostedClocksEnabled == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5765, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5766
 *     global __nvmlDeviceSetDefaultAutoBoostedClocksEnabled
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetDefaultAutoBoostedClocksEnabled == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetDefaultAutoBoostedClocksEnabled is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDefaultAutoBoostedClocksEnabled == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5767
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetDefaultAutoBoostedClocksEnabled == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetDefaultAutoBoostedClocksEnabled is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t, unsigned int) noexcept nogil>__nvmlDeviceSetDefaultAutoBoostedClocksEnabled)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5768
 *     if __nvmlDeviceSetDefaultAutoBoostedClocksEnabled == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetDefaultAutoBoostedClocksEnabled is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t, unsigned int) noexcept nogil>__nvmlDeviceSetDefaultAutoBoostedClocksEnabled)(
 *         device, enabled, flags)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5768, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetDefaultAut};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5768, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5768, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5767
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetDefaultAutoBoostedClocksEnabled == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetDefaultAutoBoostedClocksEnabled is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t, unsigned int) noexcept nogil>__nvmlDeviceSetDefaultAutoBoostedClocksEnabled)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5766
 *     global __nvmlDeviceSetDefaultAutoBoostedClocksEnabled
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetDefaultAutoBoostedClocksEnabled == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetDefaultAutoBoostedClocksEnabled is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5769
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetDefaultAutoBoostedClocksEnabled is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t, unsigned int) noexcept nogil>__nvmlDeviceSetDefaultAutoBoostedClocksEnabled)(             # <<<<<<<<<<<<<<
 *         device, enabled, flags)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDefaultAutoBoostedClocksEnabled)(__pyx_v_device, __pyx_v_enabled, __pyx_v_flags);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5763
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetDefaultAutoBoostedClocksEnabled(nvmlDevice_t device, nvmlEnableState_t enabled, unsigned int flags) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetDefaultAutoBoostedClocksEnabled
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetDefaultAutoBoostedClocksEnabled", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5773
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetDefaultFanSpeed_v2(nvmlDevice_t device, unsigned int fan) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetDefaultFanSpeed_v2
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetDefaultFanSpeed_v2(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_fan) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetDefaultFanSpeed_v2", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5775
 * cdef nvmlReturn_t _nvmlDeviceSetDefaultFanSpeed_v2(nvmlDevice_t device, unsigned int fan) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetDefaultFanSpeed_v2
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetDefaultFanSpeed_v2 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5775, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5776
 *     global __nvmlDeviceSetDefaultFanSpeed_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetDefaultFanSpeed_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetDefaultFanSpeed_v2 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDefaultFanSpeed_v2 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5777
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetDefaultFanSpeed_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetDefaultFanSpeed_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int) noexcept nogil>__nvmlDeviceSetDefaultFanSpeed_v2)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5778
 *     if __nvmlDeviceSetDefaultFanSpeed_v2 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetDefaultFanSpeed_v2 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int) noexcept nogil>__nvmlDeviceSetDefaultFanSpeed_v2)(
 *         device, fan)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5778, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetDefaultFan};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5778, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5778, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5777
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetDefaultFanSpeed_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetDefaultFanSpeed_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int) noexcept nogil>__nvmlDeviceSetDefaultFanSpeed_v2)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5776
 *     global __nvmlDeviceSetDefaultFanSpeed_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetDefaultFanSpeed_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetDefaultFanSpeed_v2 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5779
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetDefaultFanSpeed_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int) noexcept nogil>__nvmlDeviceSetDefaultFanSpeed_v2)(             # <<<<<<<<<<<<<<
 *         device, fan)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDefaultFanSpeed_v2)(__pyx_v_device, __pyx_v_fan);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5773
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetDefaultFanSpeed_v2(nvmlDevice_t device, unsigned int fan) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetDefaultFanSpeed_v2
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetDefaultFanSpeed_v2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5783
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetFanControlPolicy(nvmlDevice_t device, unsigned int fan, nvmlFanControlPolicy_t policy) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetFanControlPolicy
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetFanControlPolicy(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_fan, nvmlFanControlPolicy_t __pyx_v_policy) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetFanControlPolicy", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5785
 * cdef nvmlReturn_t _nvmlDeviceSetFanControlPolicy(nvmlDevice_t device, unsigned int fan, nvmlFanControlPolicy_t policy) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetFanControlPolicy
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetFanControlPolicy == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5785, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5786
 *     global __nvmlDeviceSetFanControlPolicy
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetFanControlPolicy == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetFanControlPolicy is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetFanControlPolicy == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5787
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetFanControlPolicy == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetFanControlPolicy is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlFanControlPolicy_t) noexcept nogil>__nvmlDeviceSetFanControlPolicy)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5788
 *     if __nvmlDeviceSetFanControlPolicy == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetFanControlPolicy is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlFanControlPolicy_t) noexcept nogil>__nvmlDeviceSetFanControlPolicy)(
 *         device, fan, policy)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5788, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetFanControl};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5788, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5788, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5787
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetFanControlPolicy == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetFanControlPolicy is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlFanControlPolicy_t) noexcept nogil>__nvmlDeviceSetFanControlPolicy)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5786
 *     global __nvmlDeviceSetFanControlPolicy
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetFanControlPolicy == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetFanControlPolicy is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5789
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetFanControlPolicy is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlFanControlPolicy_t) noexcept nogil>__nvmlDeviceSetFanControlPolicy)(             # <<<<<<<<<<<<<<
 *         device, fan, policy)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlFanControlPolicy_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetFanControlPolicy)(__pyx_v_device, __pyx_v_fan, __pyx_v_policy);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5783
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetFanControlPolicy(nvmlDevice_t device, unsigned int fan, nvmlFanControlPolicy_t policy) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetFanControlPolicy
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetFanControlPolicy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5793
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetTemperatureThreshold(nvmlDevice_t device, nvmlTemperatureThresholds_t thresholdType, int* temp) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetTemperatureThreshold
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetTemperatureThreshold(nvmlDevice_t __pyx_v_device, nvmlTemperatureThresholds_t __pyx_v_thresholdType, int *__pyx_v_temp) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetTemperatureThreshold", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5795
 * cdef nvmlReturn_t _nvmlDeviceSetTemperatureThreshold(nvmlDevice_t device, nvmlTemperatureThresholds_t thresholdType, int* temp) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetTemperatureThreshold
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetTemperatureThreshold == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5795, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5796
 *     global __nvmlDeviceSetTemperatureThreshold
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetTemperatureThreshold == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetTemperatureThreshold is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetTemperatureThreshold == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5797
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetTemperatureThreshold == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetTemperatureThreshold is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlTemperatureThresholds_t, int*) noexcept nogil>__nvmlDeviceSetTemperatureThreshold)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5798
 *     if __nvmlDeviceSetTemperatureThreshold == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetTemperatureThreshold is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlTemperatureThresholds_t, int*) noexcept nogil>__nvmlDeviceSetTemperatureThreshold)(
 *         device, thresholdType, temp)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5798, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetTemperatur};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5798, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5798, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5797
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetTemperatureThreshold == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetTemperatureThreshold is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlTemperatureThresholds_t, int*) noexcept nogil>__nvmlDeviceSetTemperatureThreshold)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5796
 *     global __nvmlDeviceSetTemperatureThreshold
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetTemperatureThreshold == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetTemperatureThreshold is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5799
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetTemperatureThreshold is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlTemperatureThresholds_t, int*) noexcept nogil>__nvmlDeviceSetTemperatureThreshold)(             # <<<<<<<<<<<<<<
 *         device, thresholdType, temp)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlTemperatureThresholds_t, int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetTemperatureThreshold)(__pyx_v_device, __pyx_v_thresholdType, __pyx_v_temp);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5793
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetTemperatureThreshold(nvmlDevice_t device, nvmlTemperatureThresholds_t thresholdType, int* temp) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetTemperatureThreshold
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetTemperatureThreshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5803
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetPowerManagementLimit(nvmlDevice_t device, unsigned int limit) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetPowerManagementLimit
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetPowerManagementLimit(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_limit) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetPowerManagementLimit", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5805
 * cdef nvmlReturn_t _nvmlDeviceSetPowerManagementLimit(nvmlDevice_t device, unsigned int limit) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetPowerManagementLimit
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetPowerManagementLimit == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5805, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5806
 *     global __nvmlDeviceSetPowerManagementLimit
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetPowerManagementLimit == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetPowerManagementLimit is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPowerManagementLimit == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5807
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetPowerManagementLimit == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetPowerManagementLimit is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int) noexcept nogil>__nvmlDeviceSetPowerManagementLimit)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5808
 *     if __nvmlDeviceSetPowerManagementLimit == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetPowerManagementLimit is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int) noexcept nogil>__nvmlDeviceSetPowerManagementLimit)(
 *         device, limit)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5808, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetPowerManag};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5808, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5808, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5807
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetPowerManagementLimit == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetPowerManagementLimit is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int) noexcept nogil>__nvmlDeviceSetPowerManagementLimit)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5806
 *     global __nvmlDeviceSetPowerManagementLimit
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetPowerManagementLimit == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetPowerManagementLimit is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5809
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetPowerManagementLimit is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int) noexcept nogil>__nvmlDeviceSetPowerManagementLimit)(             # <<<<<<<<<<<<<<
 *         device, limit)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPowerManagementLimit)(__pyx_v_device, __pyx_v_limit);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5803
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetPowerManagementLimit(nvmlDevice_t device, unsigned int limit) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetPowerManagementLimit
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetPowerManagementLimit", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5813
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetGpuOperationMode(nvmlDevice_t device, nvmlGpuOperationMode_t mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetGpuOperationMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetGpuOperationMode(nvmlDevice_t __pyx_v_device, nvmlGpuOperationMode_t __pyx_v_mode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetGpuOperationMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5815
 * cdef nvmlReturn_t _nvmlDeviceSetGpuOperationMode(nvmlDevice_t device, nvmlGpuOperationMode_t mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetGpuOperationMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetGpuOperationMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5815, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5816
 *     global __nvmlDeviceSetGpuOperationMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetGpuOperationMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetGpuOperationMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetGpuOperationMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5817
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetGpuOperationMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetGpuOperationMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuOperationMode_t) noexcept nogil>__nvmlDeviceSetGpuOperationMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5818
 *     if __nvmlDeviceSetGpuOperationMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetGpuOperationMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuOperationMode_t) noexcept nogil>__nvmlDeviceSetGpuOperationMode)(
 *         device, mode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5818, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetGpuOperati};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5818, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5818, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5817
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetGpuOperationMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetGpuOperationMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuOperationMode_t) noexcept nogil>__nvmlDeviceSetGpuOperationMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5816
 *     global __nvmlDeviceSetGpuOperationMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetGpuOperationMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetGpuOperationMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5819
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetGpuOperationMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuOperationMode_t) noexcept nogil>__nvmlDeviceSetGpuOperationMode)(             # <<<<<<<<<<<<<<
 *         device, mode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuOperationMode_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetGpuOperationMode)(__pyx_v_device, __pyx_v_mode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5813
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetGpuOperationMode(nvmlDevice_t device, nvmlGpuOperationMode_t mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetGpuOperationMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetGpuOperationMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5823
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetAPIRestriction(nvmlDevice_t device, nvmlRestrictedAPI_t apiType, nvmlEnableState_t isRestricted) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetAPIRestriction
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetAPIRestriction(nvmlDevice_t __pyx_v_device, nvmlRestrictedAPI_t __pyx_v_apiType, nvmlEnableState_t __pyx_v_isRestricted) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetAPIRestriction", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5825
 * cdef nvmlReturn_t _nvmlDeviceSetAPIRestriction(nvmlDevice_t device, nvmlRestrictedAPI_t apiType, nvmlEnableState_t isRestricted) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetAPIRestriction
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetAPIRestriction == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5825, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5826
 *     global __nvmlDeviceSetAPIRestriction
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetAPIRestriction == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetAPIRestriction is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetAPIRestriction == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5827
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetAPIRestriction == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetAPIRestriction is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlRestrictedAPI_t, nvmlEnableState_t) noexcept nogil>__nvmlDeviceSetAPIRestriction)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5828
 *     if __nvmlDeviceSetAPIRestriction == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetAPIRestriction is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlRestrictedAPI_t, nvmlEnableState_t) noexcept nogil>__nvmlDeviceSetAPIRestriction)(
 *         device, apiType, isRestricted)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5828, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetAPIRestric};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5828, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5828, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5827
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetAPIRestriction == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetAPIRestriction is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlRestrictedAPI_t, nvmlEnableState_t) noexcept nogil>__nvmlDeviceSetAPIRestriction)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5826
 *     global __nvmlDeviceSetAPIRestriction
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetAPIRestriction == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetAPIRestriction is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5829
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetAPIRestriction is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlRestrictedAPI_t, nvmlEnableState_t) noexcept nogil>__nvmlDeviceSetAPIRestriction)(             # <<<<<<<<<<<<<<
 *         device, apiType, isRestricted)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlRestrictedAPI_t, nvmlEnableState_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetAPIRestriction)(__pyx_v_device, __pyx_v_apiType, __pyx_v_isRestricted);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5823
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetAPIRestriction(nvmlDevice_t device, nvmlRestrictedAPI_t apiType, nvmlEnableState_t isRestricted) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetAPIRestriction
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetAPIRestriction", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5833
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetFanSpeed_v2(nvmlDevice_t device, unsigned int fan, unsigned int speed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetFanSpeed_v2
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetFanSpeed_v2(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_fan, unsigned int __pyx_v_speed) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetFanSpeed_v2", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5835
 * cdef nvmlReturn_t _nvmlDeviceSetFanSpeed_v2(nvmlDevice_t device, unsigned int fan, unsigned int speed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetFanSpeed_v2
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetFanSpeed_v2 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5835, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5836
 *     global __nvmlDeviceSetFanSpeed_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetFanSpeed_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetFanSpeed_v2 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetFanSpeed_v2 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5837
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetFanSpeed_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetFanSpeed_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int) noexcept nogil>__nvmlDeviceSetFanSpeed_v2)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5838
 *     if __nvmlDeviceSetFanSpeed_v2 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetFanSpeed_v2 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int) noexcept nogil>__nvmlDeviceSetFanSpeed_v2)(
 *         device, fan, speed)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5838, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetFanSpeed_v};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5838, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5838, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5837
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetFanSpeed_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetFanSpeed_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int) noexcept nogil>__nvmlDeviceSetFanSpeed_v2)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5836
 *     global __nvmlDeviceSetFanSpeed_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetFanSpeed_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetFanSpeed_v2 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5839
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetFanSpeed_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int) noexcept nogil>__nvmlDeviceSetFanSpeed_v2)(             # <<<<<<<<<<<<<<
 *         device, fan, speed)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetFanSpeed_v2)(__pyx_v_device, __pyx_v_fan, __pyx_v_speed);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5833
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetFanSpeed_v2(nvmlDevice_t device, unsigned int fan, unsigned int speed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetFanSpeed_v2
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetFanSpeed_v2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5843
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetAccountingMode(nvmlDevice_t device, nvmlEnableState_t mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetAccountingMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetAccountingMode(nvmlDevice_t __pyx_v_device, nvmlEnableState_t __pyx_v_mode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetAccountingMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5845
 * cdef nvmlReturn_t _nvmlDeviceSetAccountingMode(nvmlDevice_t device, nvmlEnableState_t mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetAccountingMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetAccountingMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5845, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5846
 *     global __nvmlDeviceSetAccountingMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetAccountingMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetAccountingMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetAccountingMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5847
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetAccountingMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetAccountingMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t) noexcept nogil>__nvmlDeviceSetAccountingMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5848
 *     if __nvmlDeviceSetAccountingMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetAccountingMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t) noexcept nogil>__nvmlDeviceSetAccountingMode)(
 *         device, mode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5848, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetAccounting};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5848, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5848, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5847
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetAccountingMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetAccountingMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t) noexcept nogil>__nvmlDeviceSetAccountingMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5846
 *     global __nvmlDeviceSetAccountingMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetAccountingMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetAccountingMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5849
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetAccountingMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t) noexcept nogil>__nvmlDeviceSetAccountingMode)(             # <<<<<<<<<<<<<<
 *         device, mode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlEnableState_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetAccountingMode)(__pyx_v_device, __pyx_v_mode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5843
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetAccountingMode(nvmlDevice_t device, nvmlEnableState_t mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetAccountingMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetAccountingMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5853
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceClearAccountingPids(nvmlDevice_t device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceClearAccountingPids
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceClearAccountingPids(nvmlDevice_t __pyx_v_device) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceClearAccountingPids", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5855
 * cdef nvmlReturn_t _nvmlDeviceClearAccountingPids(nvmlDevice_t device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceClearAccountingPids
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceClearAccountingPids == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5855, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5856
 *     global __nvmlDeviceClearAccountingPids
 *     _check_or_init_nvml()
 *     if __nvmlDeviceClearAccountingPids == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceClearAccountingPids is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearAccountingPids == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5857
 *     _check_or_init_nvml()
 *     if __nvmlDeviceClearAccountingPids == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceClearAccountingPids is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t) noexcept nogil>__nvmlDeviceClearAccountingPids)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5858
 *     if __nvmlDeviceClearAccountingPids == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceClearAccountingPids is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t) noexcept nogil>__nvmlDeviceClearAccountingPids)(
 *         device)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5858, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceClearAccounti};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5858, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5858, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5857
 *     _check_or_init_nvml()
 *     if __nvmlDeviceClearAccountingPids == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceClearAccountingPids is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t) noexcept nogil>__nvmlDeviceClearAccountingPids)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5856
 *     global __nvmlDeviceClearAccountingPids
 *     _check_or_init_nvml()
 *     if __nvmlDeviceClearAccountingPids == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceClearAccountingPids is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5859
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceClearAccountingPids is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t) noexcept nogil>__nvmlDeviceClearAccountingPids)(             # <<<<<<<<<<<<<<
 *         device)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearAccountingPids)(__pyx_v_device);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5853
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceClearAccountingPids(nvmlDevice_t device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceClearAccountingPids
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceClearAccountingPids", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5863
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetPowerManagementLimit_v2(nvmlDevice_t device, nvmlPowerValue_v2_t* powerValue) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetPowerManagementLimit_v2
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetPowerManagementLimit_v2(nvmlDevice_t __pyx_v_device, nvmlPowerValue_v2_t *__pyx_v_powerValue) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetPowerManagementLimit_v2", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5865
 * cdef nvmlReturn_t _nvmlDeviceSetPowerManagementLimit_v2(nvmlDevice_t device, nvmlPowerValue_v2_t* powerValue) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetPowerManagementLimit_v2
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetPowerManagementLimit_v2 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5865, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5866
 *     global __nvmlDeviceSetPowerManagementLimit_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetPowerManagementLimit_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetPowerManagementLimit_v2 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPowerManagementLimit_v2 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5867
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetPowerManagementLimit_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetPowerManagementLimit_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerValue_v2_t*) noexcept nogil>__nvmlDeviceSetPowerManagementLimit_v2)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5868
 *     if __nvmlDeviceSetPowerManagementLimit_v2 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetPowerManagementLimit_v2 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerValue_v2_t*) noexcept nogil>__nvmlDeviceSetPowerManagementLimit_v2)(
 *         device, powerValue)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5868, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetPowerManag_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5868, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5868, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5867
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetPowerManagementLimit_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetPowerManagementLimit_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerValue_v2_t*) noexcept nogil>__nvmlDeviceSetPowerManagementLimit_v2)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5866
 *     global __nvmlDeviceSetPowerManagementLimit_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetPowerManagementLimit_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetPowerManagementLimit_v2 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5869
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetPowerManagementLimit_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerValue_v2_t*) noexcept nogil>__nvmlDeviceSetPowerManagementLimit_v2)(             # <<<<<<<<<<<<<<
 *         device, powerValue)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerValue_v2_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPowerManagementLimit_v2)(__pyx_v_device, __pyx_v_powerValue);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5863
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetPowerManagementLimit_v2(nvmlDevice_t device, nvmlPowerValue_v2_t* powerValue) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetPowerManagementLimit_v2
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetPowerManagementLimit_v2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5873
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetNvLinkState(nvmlDevice_t device, unsigned int link, nvmlEnableState_t* isActive) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetNvLinkState
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetNvLinkState(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_link, nvmlEnableState_t *__pyx_v_isActive) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetNvLinkState", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5875
 * cdef nvmlReturn_t _nvmlDeviceGetNvLinkState(nvmlDevice_t device, unsigned int link, nvmlEnableState_t* isActive) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetNvLinkState
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetNvLinkState == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5875, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5876
 *     global __nvmlDeviceGetNvLinkState
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkState is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkState == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5877
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkState is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetNvLinkState)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5878
 *     if __nvmlDeviceGetNvLinkState == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkState is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetNvLinkState)(
 *         device, link, isActive)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5878, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetNvLinkStat};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5878, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5878, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5877
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkState is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetNvLinkState)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5876
 *     global __nvmlDeviceGetNvLinkState
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkState is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5879
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkState is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceGetNvLinkState)(             # <<<<<<<<<<<<<<
 *         device, link, isActive)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlEnableState_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkState)(__pyx_v_device, __pyx_v_link, __pyx_v_isActive);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5873
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetNvLinkState(nvmlDevice_t device, unsigned int link, nvmlEnableState_t* isActive) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetNvLinkState
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetNvLinkState", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5883
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetNvLinkVersion(nvmlDevice_t device, unsigned int link, unsigned int* version) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetNvLinkVersion
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetNvLinkVersion(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_link, unsigned int *__pyx_v_version) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetNvLinkVersion", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5885
 * cdef nvmlReturn_t _nvmlDeviceGetNvLinkVersion(nvmlDevice_t device, unsigned int link, unsigned int* version) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetNvLinkVersion
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetNvLinkVersion == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5885, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5886
 *     global __nvmlDeviceGetNvLinkVersion
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkVersion == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkVersion is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkVersion == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5887
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkVersion == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkVersion is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int*) noexcept nogil>__nvmlDeviceGetNvLinkVersion)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5888
 *     if __nvmlDeviceGetNvLinkVersion == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkVersion is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int*) noexcept nogil>__nvmlDeviceGetNvLinkVersion)(
 *         device, link, version)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5888, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetNvLinkVers};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5888, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5888, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5887
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkVersion == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkVersion is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int*) noexcept nogil>__nvmlDeviceGetNvLinkVersion)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5886
 *     global __nvmlDeviceGetNvLinkVersion
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkVersion == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkVersion is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5889
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkVersion is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int*) noexcept nogil>__nvmlDeviceGetNvLinkVersion)(             # <<<<<<<<<<<<<<
 *         device, link, version)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkVersion)(__pyx_v_device, __pyx_v_link, __pyx_v_version);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5883
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetNvLinkVersion(nvmlDevice_t device, unsigned int link, unsigned int* version) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetNvLinkVersion
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetNvLinkVersion", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5893
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetNvLinkCapability(nvmlDevice_t device, unsigned int link, nvmlNvLinkCapability_t capability, unsigned int* capResult) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetNvLinkCapability
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetNvLinkCapability(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_link, nvmlNvLinkCapability_t __pyx_v_capability, unsigned int *__pyx_v_capResult) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetNvLinkCapability", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5895
 * cdef nvmlReturn_t _nvmlDeviceGetNvLinkCapability(nvmlDevice_t device, unsigned int link, nvmlNvLinkCapability_t capability, unsigned int* capResult) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetNvLinkCapability
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetNvLinkCapability == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5895, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5896
 *     global __nvmlDeviceGetNvLinkCapability
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkCapability == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkCapability is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkCapability == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5897
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkCapability == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkCapability is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlNvLinkCapability_t, unsigned int*) noexcept nogil>__nvmlDeviceGetNvLinkCapability)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5898
 *     if __nvmlDeviceGetNvLinkCapability == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkCapability is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlNvLinkCapability_t, unsigned int*) noexcept nogil>__nvmlDeviceGetNvLinkCapability)(
 *         device, link, capability, capResult)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5898, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetNvLinkCapa};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5898, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5898, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5897
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkCapability == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkCapability is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlNvLinkCapability_t, unsigned int*) noexcept nogil>__nvmlDeviceGetNvLinkCapability)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5896
 *     global __nvmlDeviceGetNvLinkCapability
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkCapability == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkCapability is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5899
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkCapability is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlNvLinkCapability_t, unsigned int*) noexcept nogil>__nvmlDeviceGetNvLinkCapability)(             # <<<<<<<<<<<<<<
 *         device, link, capability, capResult)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlNvLinkCapability_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkCapability)(__pyx_v_device, __pyx_v_link, __pyx_v_capability, __pyx_v_capResult);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5893
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetNvLinkCapability(nvmlDevice_t device, unsigned int link, nvmlNvLinkCapability_t capability, unsigned int* capResult) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetNvLinkCapability
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetNvLinkCapability", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5903
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetNvLinkRemotePciInfo_v2(nvmlDevice_t device, unsigned int link, nvmlPciInfo_t* pci) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetNvLinkRemotePciInfo_v2
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetNvLinkRemotePciInfo_v2(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_link, nvmlPciInfo_t *__pyx_v_pci) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetNvLinkRemotePciInfo_v2", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5905
 * cdef nvmlReturn_t _nvmlDeviceGetNvLinkRemotePciInfo_v2(nvmlDevice_t device, unsigned int link, nvmlPciInfo_t* pci) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetNvLinkRemotePciInfo_v2
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetNvLinkRemotePciInfo_v2 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5905, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5906
 *     global __nvmlDeviceGetNvLinkRemotePciInfo_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkRemotePciInfo_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkRemotePciInfo_v2 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkRemotePciInfo_v2 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5907
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkRemotePciInfo_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkRemotePciInfo_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlPciInfo_t*) noexcept nogil>__nvmlDeviceGetNvLinkRemotePciInfo_v2)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5908
 *     if __nvmlDeviceGetNvLinkRemotePciInfo_v2 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkRemotePciInfo_v2 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlPciInfo_t*) noexcept nogil>__nvmlDeviceGetNvLinkRemotePciInfo_v2)(
 *         device, link, pci)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5908, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetNvLinkRemo};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5908, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5908, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5907
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkRemotePciInfo_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkRemotePciInfo_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlPciInfo_t*) noexcept nogil>__nvmlDeviceGetNvLinkRemotePciInfo_v2)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5906
 *     global __nvmlDeviceGetNvLinkRemotePciInfo_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkRemotePciInfo_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkRemotePciInfo_v2 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5909
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkRemotePciInfo_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlPciInfo_t*) noexcept nogil>__nvmlDeviceGetNvLinkRemotePciInfo_v2)(             # <<<<<<<<<<<<<<
 *         device, link, pci)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlPciInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkRemotePciInfo_v2)(__pyx_v_device, __pyx_v_link, __pyx_v_pci);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5903
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetNvLinkRemotePciInfo_v2(nvmlDevice_t device, unsigned int link, nvmlPciInfo_t* pci) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetNvLinkRemotePciInfo_v2
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetNvLinkRemotePciInfo_v2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5913
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetNvLinkErrorCounter(nvmlDevice_t device, unsigned int link, nvmlNvLinkErrorCounter_t counter, unsigned long long* counterValue) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetNvLinkErrorCounter
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetNvLinkErrorCounter(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_link, nvmlNvLinkErrorCounter_t __pyx_v_counter, unsigned PY_LONG_LONG *__pyx_v_counterValue) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetNvLinkErrorCounter", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5915
 * cdef nvmlReturn_t _nvmlDeviceGetNvLinkErrorCounter(nvmlDevice_t device, unsigned int link, nvmlNvLinkErrorCounter_t counter, unsigned long long* counterValue) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetNvLinkErrorCounter
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetNvLinkErrorCounter == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5915, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5916
 *     global __nvmlDeviceGetNvLinkErrorCounter
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkErrorCounter == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkErrorCounter is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkErrorCounter == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5917
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkErrorCounter == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkErrorCounter is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlNvLinkErrorCounter_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetNvLinkErrorCounter)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5918
 *     if __nvmlDeviceGetNvLinkErrorCounter == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkErrorCounter is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlNvLinkErrorCounter_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetNvLinkErrorCounter)(
 *         device, link, counter, counterValue)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5918, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetNvLinkErro};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5918, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5918, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5917
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkErrorCounter == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkErrorCounter is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlNvLinkErrorCounter_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetNvLinkErrorCounter)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5916
 *     global __nvmlDeviceGetNvLinkErrorCounter
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkErrorCounter == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkErrorCounter is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5919
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkErrorCounter is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlNvLinkErrorCounter_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetNvLinkErrorCounter)(             # <<<<<<<<<<<<<<
 *         device, link, counter, counterValue)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlNvLinkErrorCounter_t, unsigned PY_LONG_LONG *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkErrorCounter)(__pyx_v_device, __pyx_v_link, __pyx_v_counter, __pyx_v_counterValue);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5913
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetNvLinkErrorCounter(nvmlDevice_t device, unsigned int link, nvmlNvLinkErrorCounter_t counter, unsigned long long* counterValue) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetNvLinkErrorCounter
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetNvLinkErrorCounter", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5923
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceResetNvLinkErrorCounters(nvmlDevice_t device, unsigned int link) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceResetNvLinkErrorCounters
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceResetNvLinkErrorCounters(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_link) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceResetNvLinkErrorCounters", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5925
 * cdef nvmlReturn_t _nvmlDeviceResetNvLinkErrorCounters(nvmlDevice_t device, unsigned int link) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceResetNvLinkErrorCounters
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceResetNvLinkErrorCounters == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5925, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5926
 *     global __nvmlDeviceResetNvLinkErrorCounters
 *     _check_or_init_nvml()
 *     if __nvmlDeviceResetNvLinkErrorCounters == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceResetNvLinkErrorCounters is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceResetNvLinkErrorCounters == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5927
 *     _check_or_init_nvml()
 *     if __nvmlDeviceResetNvLinkErrorCounters == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceResetNvLinkErrorCounters is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int) noexcept nogil>__nvmlDeviceResetNvLinkErrorCounters)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5928
 *     if __nvmlDeviceResetNvLinkErrorCounters == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceResetNvLinkErrorCounters is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int) noexcept nogil>__nvmlDeviceResetNvLinkErrorCounters)(
 *         device, link)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5928, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceResetNvLinkEr};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5928, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5928, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5927
 *     _check_or_init_nvml()
 *     if __nvmlDeviceResetNvLinkErrorCounters == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceResetNvLinkErrorCounters is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int) noexcept nogil>__nvmlDeviceResetNvLinkErrorCounters)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5926
 *     global __nvmlDeviceResetNvLinkErrorCounters
 *     _check_or_init_nvml()
 *     if __nvmlDeviceResetNvLinkErrorCounters == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceResetNvLinkErrorCounters is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5929
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceResetNvLinkErrorCounters is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int) noexcept nogil>__nvmlDeviceResetNvLinkErrorCounters)(             # <<<<<<<<<<<<<<
 *         device, link)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceResetNvLinkErrorCounters)(__pyx_v_device, __pyx_v_link);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5923
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceResetNvLinkErrorCounters(nvmlDevice_t device, unsigned int link) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceResetNvLinkErrorCounters
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceResetNvLinkErrorCounters", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5933
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetNvLinkRemoteDeviceType(nvmlDevice_t device, unsigned int link, nvmlIntNvLinkDeviceType_t* pNvLinkDeviceType) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetNvLinkRemoteDeviceType
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetNvLinkRemoteDeviceType(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_link, nvmlIntNvLinkDeviceType_t *__pyx_v_pNvLinkDeviceType) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetNvLinkRemoteDeviceType", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5935
 * cdef nvmlReturn_t _nvmlDeviceGetNvLinkRemoteDeviceType(nvmlDevice_t device, unsigned int link, nvmlIntNvLinkDeviceType_t* pNvLinkDeviceType) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetNvLinkRemoteDeviceType
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetNvLinkRemoteDeviceType == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5935, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5936
 *     global __nvmlDeviceGetNvLinkRemoteDeviceType
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkRemoteDeviceType == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkRemoteDeviceType is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkRemoteDeviceType == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5937
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkRemoteDeviceType == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkRemoteDeviceType is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlIntNvLinkDeviceType_t*) noexcept nogil>__nvmlDeviceGetNvLinkRemoteDeviceType)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5938
 *     if __nvmlDeviceGetNvLinkRemoteDeviceType == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkRemoteDeviceType is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlIntNvLinkDeviceType_t*) noexcept nogil>__nvmlDeviceGetNvLinkRemoteDeviceType)(
 *         device, link, pNvLinkDeviceType)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5938, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetNvLinkRemo_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5938, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5938, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5937
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkRemoteDeviceType == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkRemoteDeviceType is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlIntNvLinkDeviceType_t*) noexcept nogil>__nvmlDeviceGetNvLinkRemoteDeviceType)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5936
 *     global __nvmlDeviceGetNvLinkRemoteDeviceType
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkRemoteDeviceType == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkRemoteDeviceType is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5939
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkRemoteDeviceType is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlIntNvLinkDeviceType_t*) noexcept nogil>__nvmlDeviceGetNvLinkRemoteDeviceType)(             # <<<<<<<<<<<<<<
 *         device, link, pNvLinkDeviceType)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlIntNvLinkDeviceType_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkRemoteDeviceType)(__pyx_v_device, __pyx_v_link, __pyx_v_pNvLinkDeviceType);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5933
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetNvLinkRemoteDeviceType(nvmlDevice_t device, unsigned int link, nvmlIntNvLinkDeviceType_t* pNvLinkDeviceType) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetNvLinkRemoteDeviceType
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetNvLinkRemoteDeviceType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5943
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetNvLinkDeviceLowPowerThreshold(nvmlDevice_t device, nvmlNvLinkPowerThres_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetNvLinkDeviceLowPowerThreshold
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetNvLinkDeviceLowPowerThreshold(nvmlDevice_t __pyx_v_device, nvmlNvLinkPowerThres_t *__pyx_v_info) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetNvLinkDeviceLowPowerThreshold", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5945
 * cdef nvmlReturn_t _nvmlDeviceSetNvLinkDeviceLowPowerThreshold(nvmlDevice_t device, nvmlNvLinkPowerThres_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetNvLinkDeviceLowPowerThreshold
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetNvLinkDeviceLowPowerThreshold == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5945, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5946
 *     global __nvmlDeviceSetNvLinkDeviceLowPowerThreshold
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetNvLinkDeviceLowPowerThreshold == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetNvLinkDeviceLowPowerThreshold is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetNvLinkDeviceLowPowerThreshold == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5947
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetNvLinkDeviceLowPowerThreshold == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetNvLinkDeviceLowPowerThreshold is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlNvLinkPowerThres_t*) noexcept nogil>__nvmlDeviceSetNvLinkDeviceLowPowerThreshold)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5948
 *     if __nvmlDeviceSetNvLinkDeviceLowPowerThreshold == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetNvLinkDeviceLowPowerThreshold is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlNvLinkPowerThres_t*) noexcept nogil>__nvmlDeviceSetNvLinkDeviceLowPowerThreshold)(
 *         device, info)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5948, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetNvLinkDevi};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5948, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5948, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5947
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetNvLinkDeviceLowPowerThreshold == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetNvLinkDeviceLowPowerThreshold is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlNvLinkPowerThres_t*) noexcept nogil>__nvmlDeviceSetNvLinkDeviceLowPowerThreshold)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5946
 *     global __nvmlDeviceSetNvLinkDeviceLowPowerThreshold
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetNvLinkDeviceLowPowerThreshold == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetNvLinkDeviceLowPowerThreshold is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5949
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetNvLinkDeviceLowPowerThreshold is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlNvLinkPowerThres_t*) noexcept nogil>__nvmlDeviceSetNvLinkDeviceLowPowerThreshold)(             # <<<<<<<<<<<<<<
 *         device, info)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlNvLinkPowerThres_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetNvLinkDeviceLowPowerThreshold)(__pyx_v_device, __pyx_v_info);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5943
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetNvLinkDeviceLowPowerThreshold(nvmlDevice_t device, nvmlNvLinkPowerThres_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetNvLinkDeviceLowPowerThreshold
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetNvLinkDeviceLowPowerThreshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5953
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemSetNvlinkBwMode(unsigned int nvlinkBwMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemSetNvlinkBwMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemSetNvlinkBwMode(unsigned int __pyx_v_nvlinkBwMode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlSystemSetNvlinkBwMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5955
 * cdef nvmlReturn_t _nvmlSystemSetNvlinkBwMode(unsigned int nvlinkBwMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlSystemSetNvlinkBwMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlSystemSetNvlinkBwMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5955, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5956
 *     global __nvmlSystemSetNvlinkBwMode
 *     _check_or_init_nvml()
 *     if __nvmlSystemSetNvlinkBwMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemSetNvlinkBwMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemSetNvlinkBwMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5957
 *     _check_or_init_nvml()
 *     if __nvmlSystemSetNvlinkBwMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemSetNvlinkBwMode is not found")
 *     return (<nvmlReturn_t (*)(unsigned int) noexcept nogil>__nvmlSystemSetNvlinkBwMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5958
 *     if __nvmlSystemSetNvlinkBwMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemSetNvlinkBwMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(unsigned int) noexcept nogil>__nvmlSystemSetNvlinkBwMode)(
 *         nvlinkBwMode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5958, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlSystemSetNvlinkBwMo};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5958, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5958, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5957
 *     _check_or_init_nvml()
 *     if __nvmlSystemSetNvlinkBwMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemSetNvlinkBwMode is not found")
 *     return (<nvmlReturn_t (*)(unsigned int) noexcept nogil>__nvmlSystemSetNvlinkBwMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5956
 *     global __nvmlSystemSetNvlinkBwMode
 *     _check_or_init_nvml()
 *     if __nvmlSystemSetNvlinkBwMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemSetNvlinkBwMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5959
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemSetNvlinkBwMode is not found")
 *     return (<nvmlReturn_t (*)(unsigned int) noexcept nogil>__nvmlSystemSetNvlinkBwMode)(             # <<<<<<<<<<<<<<
 *         nvlinkBwMode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemSetNvlinkBwMode)(__pyx_v_nvlinkBwMode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5953
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemSetNvlinkBwMode(unsigned int nvlinkBwMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemSetNvlinkBwMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlSystemSetNvlinkBwMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5963
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetNvlinkBwMode(unsigned int* nvlinkBwMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetNvlinkBwMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetNvlinkBwMode(unsigned int *__pyx_v_nvlinkBwMode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlSystemGetNvlinkBwMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5965
 * cdef nvmlReturn_t _nvmlSystemGetNvlinkBwMode(unsigned int* nvlinkBwMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlSystemGetNvlinkBwMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlSystemGetNvlinkBwMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5965, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5966
 *     global __nvmlSystemGetNvlinkBwMode
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetNvlinkBwMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetNvlinkBwMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetNvlinkBwMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5967
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetNvlinkBwMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetNvlinkBwMode is not found")
 *     return (<nvmlReturn_t (*)(unsigned int*) noexcept nogil>__nvmlSystemGetNvlinkBwMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5968
 *     if __nvmlSystemGetNvlinkBwMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetNvlinkBwMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(unsigned int*) noexcept nogil>__nvmlSystemGetNvlinkBwMode)(
 *         nvlinkBwMode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5968, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlSystemGetNvlinkBwMo};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5968, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5968, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5967
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetNvlinkBwMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemGetNvlinkBwMode is not found")
 *     return (<nvmlReturn_t (*)(unsigned int*) noexcept nogil>__nvmlSystemGetNvlinkBwMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5966
 *     global __nvmlSystemGetNvlinkBwMode
 *     _check_or_init_nvml()
 *     if __nvmlSystemGetNvlinkBwMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetNvlinkBwMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5969
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemGetNvlinkBwMode is not found")
 *     return (<nvmlReturn_t (*)(unsigned int*) noexcept nogil>__nvmlSystemGetNvlinkBwMode)(             # <<<<<<<<<<<<<<
 *         nvlinkBwMode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetNvlinkBwMode)(__pyx_v_nvlinkBwMode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5963
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemGetNvlinkBwMode(unsigned int* nvlinkBwMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemGetNvlinkBwMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlSystemGetNvlinkBwMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5973
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetNvlinkSupportedBwModes(nvmlDevice_t device, nvmlNvlinkSupportedBwModes_t* supportedBwMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetNvlinkSupportedBwModes
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetNvlinkSupportedBwModes(nvmlDevice_t __pyx_v_device, nvmlNvlinkSupportedBwModes_t *__pyx_v_supportedBwMode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetNvlinkSupportedBwModes", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5975
 * cdef nvmlReturn_t _nvmlDeviceGetNvlinkSupportedBwModes(nvmlDevice_t device, nvmlNvlinkSupportedBwModes_t* supportedBwMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetNvlinkSupportedBwModes
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetNvlinkSupportedBwModes == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5975, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5976
 *     global __nvmlDeviceGetNvlinkSupportedBwModes
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvlinkSupportedBwModes == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvlinkSupportedBwModes is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvlinkSupportedBwModes == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5977
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvlinkSupportedBwModes == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvlinkSupportedBwModes is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlNvlinkSupportedBwModes_t*) noexcept nogil>__nvmlDeviceGetNvlinkSupportedBwModes)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5978
 *     if __nvmlDeviceGetNvlinkSupportedBwModes == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvlinkSupportedBwModes is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlNvlinkSupportedBwModes_t*) noexcept nogil>__nvmlDeviceGetNvlinkSupportedBwModes)(
 *         device, supportedBwMode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5978, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetNvlinkSupp};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5978, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5978, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5977
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvlinkSupportedBwModes == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvlinkSupportedBwModes is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlNvlinkSupportedBwModes_t*) noexcept nogil>__nvmlDeviceGetNvlinkSupportedBwModes)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5976
 *     global __nvmlDeviceGetNvlinkSupportedBwModes
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvlinkSupportedBwModes == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvlinkSupportedBwModes is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5979
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvlinkSupportedBwModes is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlNvlinkSupportedBwModes_t*) noexcept nogil>__nvmlDeviceGetNvlinkSupportedBwModes)(             # <<<<<<<<<<<<<<
 *         device, supportedBwMode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlNvlinkSupportedBwModes_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvlinkSupportedBwModes)(__pyx_v_device, __pyx_v_supportedBwMode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5973
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetNvlinkSupportedBwModes(nvmlDevice_t device, nvmlNvlinkSupportedBwModes_t* supportedBwMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetNvlinkSupportedBwModes
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetNvlinkSupportedBwModes", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5983
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetNvlinkBwMode(nvmlDevice_t device, nvmlNvlinkGetBwMode_t* getBwMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetNvlinkBwMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetNvlinkBwMode(nvmlDevice_t __pyx_v_device, nvmlNvlinkGetBwMode_t *__pyx_v_getBwMode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetNvlinkBwMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5985
 * cdef nvmlReturn_t _nvmlDeviceGetNvlinkBwMode(nvmlDevice_t device, nvmlNvlinkGetBwMode_t* getBwMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetNvlinkBwMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetNvlinkBwMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5985, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5986
 *     global __nvmlDeviceGetNvlinkBwMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvlinkBwMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvlinkBwMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvlinkBwMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5987
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvlinkBwMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvlinkBwMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlNvlinkGetBwMode_t*) noexcept nogil>__nvmlDeviceGetNvlinkBwMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5988
 *     if __nvmlDeviceGetNvlinkBwMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvlinkBwMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlNvlinkGetBwMode_t*) noexcept nogil>__nvmlDeviceGetNvlinkBwMode)(
 *         device, getBwMode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5988, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetNvlinkBwMo};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5988, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5988, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5987
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvlinkBwMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvlinkBwMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlNvlinkGetBwMode_t*) noexcept nogil>__nvmlDeviceGetNvlinkBwMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5986
 *     global __nvmlDeviceGetNvlinkBwMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvlinkBwMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvlinkBwMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5989
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvlinkBwMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlNvlinkGetBwMode_t*) noexcept nogil>__nvmlDeviceGetNvlinkBwMode)(             # <<<<<<<<<<<<<<
 *         device, getBwMode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlNvlinkGetBwMode_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvlinkBwMode)(__pyx_v_device, __pyx_v_getBwMode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5983
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetNvlinkBwMode(nvmlDevice_t device, nvmlNvlinkGetBwMode_t* getBwMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetNvlinkBwMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetNvlinkBwMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":5993
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetNvlinkBwMode(nvmlDevice_t device, nvmlNvlinkSetBwMode_t* setBwMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetNvlinkBwMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetNvlinkBwMode(nvmlDevice_t __pyx_v_device, nvmlNvlinkSetBwMode_t *__pyx_v_setBwMode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetNvlinkBwMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":5995
 * cdef nvmlReturn_t _nvmlDeviceSetNvlinkBwMode(nvmlDevice_t device, nvmlNvlinkSetBwMode_t* setBwMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetNvlinkBwMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetNvlinkBwMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 5995, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":5996
 *     global __nvmlDeviceSetNvlinkBwMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetNvlinkBwMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetNvlinkBwMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetNvlinkBwMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":5997
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetNvlinkBwMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetNvlinkBwMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlNvlinkSetBwMode_t*) noexcept nogil>__nvmlDeviceSetNvlinkBwMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":5998
 *     if __nvmlDeviceSetNvlinkBwMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetNvlinkBwMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlNvlinkSetBwMode_t*) noexcept nogil>__nvmlDeviceSetNvlinkBwMode)(
 *         device, setBwMode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5998, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetNvlinkBwMo};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5998, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 5998, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":5997
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetNvlinkBwMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetNvlinkBwMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlNvlinkSetBwMode_t*) noexcept nogil>__nvmlDeviceSetNvlinkBwMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":5996
 *     global __nvmlDeviceSetNvlinkBwMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetNvlinkBwMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetNvlinkBwMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":5999
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetNvlinkBwMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlNvlinkSetBwMode_t*) noexcept nogil>__nvmlDeviceSetNvlinkBwMode)(             # <<<<<<<<<<<<<<
 *         device, setBwMode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlNvlinkSetBwMode_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetNvlinkBwMode)(__pyx_v_device, __pyx_v_setBwMode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":5993
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetNvlinkBwMode(nvmlDevice_t device, nvmlNvlinkSetBwMode_t* setBwMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetNvlinkBwMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetNvlinkBwMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6003
 * 
 * 
 * cdef nvmlReturn_t _nvmlEventSetCreate(nvmlEventSet_t* set) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlEventSetCreate
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlEventSetCreate(nvmlEventSet_t *__pyx_v_set) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlEventSetCreate", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6005
 * cdef nvmlReturn_t _nvmlEventSetCreate(nvmlEventSet_t* set) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlEventSetCreate
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlEventSetCreate == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6005, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6006
 *     global __nvmlEventSetCreate
 *     _check_or_init_nvml()
 *     if __nvmlEventSetCreate == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlEventSetCreate is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlEventSetCreate == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6007
 *     _check_or_init_nvml()
 *     if __nvmlEventSetCreate == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlEventSetCreate is not found")
 *     return (<nvmlReturn_t (*)(nvmlEventSet_t*) noexcept nogil>__nvmlEventSetCreate)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6008
 *     if __nvmlEventSetCreate == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlEventSetCreate is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlEventSet_t*) noexcept nogil>__nvmlEventSetCreate)(
 *         set)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6008, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlEventSetCreate_is_n};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6008, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6008, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6007
 *     _check_or_init_nvml()
 *     if __nvmlEventSetCreate == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlEventSetCreate is not found")
 *     return (<nvmlReturn_t (*)(nvmlEventSet_t*) noexcept nogil>__nvmlEventSetCreate)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6006
 *     global __nvmlEventSetCreate
 *     _check_or_init_nvml()
 *     if __nvmlEventSetCreate == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlEventSetCreate is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6009
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlEventSetCreate is not found")
 *     return (<nvmlReturn_t (*)(nvmlEventSet_t*) noexcept nogil>__nvmlEventSetCreate)(             # <<<<<<<<<<<<<<
 *         set)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlEventSet_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlEventSetCreate)(__pyx_v_set);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6003
 * 
 * 
 * cdef nvmlReturn_t _nvmlEventSetCreate(nvmlEventSet_t* set) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlEventSetCreate
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlEventSetCreate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6013
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceRegisterEvents(nvmlDevice_t device, unsigned long long eventTypes, nvmlEventSet_t set) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceRegisterEvents
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceRegisterEvents(nvmlDevice_t __pyx_v_device, unsigned PY_LONG_LONG __pyx_v_eventTypes, nvmlEventSet_t __pyx_v_set) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceRegisterEvents", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6015
 * cdef nvmlReturn_t _nvmlDeviceRegisterEvents(nvmlDevice_t device, unsigned long long eventTypes, nvmlEventSet_t set) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceRegisterEvents
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceRegisterEvents == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6015, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6016
 *     global __nvmlDeviceRegisterEvents
 *     _check_or_init_nvml()
 *     if __nvmlDeviceRegisterEvents == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceRegisterEvents is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceRegisterEvents == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6017
 *     _check_or_init_nvml()
 *     if __nvmlDeviceRegisterEvents == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceRegisterEvents is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long, nvmlEventSet_t) noexcept nogil>__nvmlDeviceRegisterEvents)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6018
 *     if __nvmlDeviceRegisterEvents == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceRegisterEvents is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long, nvmlEventSet_t) noexcept nogil>__nvmlDeviceRegisterEvents)(
 *         device, eventTypes, set)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6018, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceRegisterEvent};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6018, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6018, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6017
 *     _check_or_init_nvml()
 *     if __nvmlDeviceRegisterEvents == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceRegisterEvents is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long, nvmlEventSet_t) noexcept nogil>__nvmlDeviceRegisterEvents)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6016
 *     global __nvmlDeviceRegisterEvents
 *     _check_or_init_nvml()
 *     if __nvmlDeviceRegisterEvents == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceRegisterEvents is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6019
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceRegisterEvents is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long, nvmlEventSet_t) noexcept nogil>__nvmlDeviceRegisterEvents)(             # <<<<<<<<<<<<<<
 *         device, eventTypes, set)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned PY_LONG_LONG, nvmlEventSet_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceRegisterEvents)(__pyx_v_device, __pyx_v_eventTypes, __pyx_v_set);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6013
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceRegisterEvents(nvmlDevice_t device, unsigned long long eventTypes, nvmlEventSet_t set) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceRegisterEvents
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceRegisterEvents", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6023
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetSupportedEventTypes(nvmlDevice_t device, unsigned long long* eventTypes) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetSupportedEventTypes
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetSupportedEventTypes(nvmlDevice_t __pyx_v_device, unsigned PY_LONG_LONG *__pyx_v_eventTypes) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetSupportedEventTypes", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6025
 * cdef nvmlReturn_t _nvmlDeviceGetSupportedEventTypes(nvmlDevice_t device, unsigned long long* eventTypes) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetSupportedEventTypes
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetSupportedEventTypes == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6025, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6026
 *     global __nvmlDeviceGetSupportedEventTypes
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSupportedEventTypes == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedEventTypes is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedEventTypes == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6027
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSupportedEventTypes == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedEventTypes is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetSupportedEventTypes)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6028
 *     if __nvmlDeviceGetSupportedEventTypes == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedEventTypes is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetSupportedEventTypes)(
 *         device, eventTypes)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6028, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetSupportedE};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6028, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6028, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6027
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSupportedEventTypes == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedEventTypes is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetSupportedEventTypes)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6026
 *     global __nvmlDeviceGetSupportedEventTypes
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSupportedEventTypes == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedEventTypes is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6029
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedEventTypes is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long*) noexcept nogil>__nvmlDeviceGetSupportedEventTypes)(             # <<<<<<<<<<<<<<
 *         device, eventTypes)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned PY_LONG_LONG *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedEventTypes)(__pyx_v_device, __pyx_v_eventTypes);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6023
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetSupportedEventTypes(nvmlDevice_t device, unsigned long long* eventTypes) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetSupportedEventTypes
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetSupportedEventTypes", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6033
 * 
 * 
 * cdef nvmlReturn_t _nvmlEventSetWait_v2(nvmlEventSet_t set, nvmlEventData_t* data, unsigned int timeoutms) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlEventSetWait_v2
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlEventSetWait_v2(nvmlEventSet_t __pyx_v_set, nvmlEventData_t *__pyx_v_data, unsigned int __pyx_v_timeoutms) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlEventSetWait_v2", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6035
 * cdef nvmlReturn_t _nvmlEventSetWait_v2(nvmlEventSet_t set, nvmlEventData_t* data, unsigned int timeoutms) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlEventSetWait_v2
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlEventSetWait_v2 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6035, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6036
 *     global __nvmlEventSetWait_v2
 *     _check_or_init_nvml()
 *     if __nvmlEventSetWait_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlEventSetWait_v2 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlEventSetWait_v2 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6037
 *     _check_or_init_nvml()
 *     if __nvmlEventSetWait_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlEventSetWait_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlEventSet_t, nvmlEventData_t*, unsigned int) noexcept nogil>__nvmlEventSetWait_v2)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6038
 *     if __nvmlEventSetWait_v2 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlEventSetWait_v2 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlEventSet_t, nvmlEventData_t*, unsigned int) noexcept nogil>__nvmlEventSetWait_v2)(
 *         set, data, timeoutms)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6038, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlEventSetWait_v2_is};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6038, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6038, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6037
 *     _check_or_init_nvml()
 *     if __nvmlEventSetWait_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlEventSetWait_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlEventSet_t, nvmlEventData_t*, unsigned int) noexcept nogil>__nvmlEventSetWait_v2)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6036
 *     global __nvmlEventSetWait_v2
 *     _check_or_init_nvml()
 *     if __nvmlEventSetWait_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlEventSetWait_v2 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6039
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlEventSetWait_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlEventSet_t, nvmlEventData_t*, unsigned int) noexcept nogil>__nvmlEventSetWait_v2)(             # <<<<<<<<<<<<<<
 *         set, data, timeoutms)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlEventSet_t, nvmlEventData_t *, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlEventSetWait_v2)(__pyx_v_set, __pyx_v_data, __pyx_v_timeoutms);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6033
 * 
 * 
 * cdef nvmlReturn_t _nvmlEventSetWait_v2(nvmlEventSet_t set, nvmlEventData_t* data, unsigned int timeoutms) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlEventSetWait_v2
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlEventSetWait_v2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6043
 * 
 * 
 * cdef nvmlReturn_t _nvmlEventSetFree(nvmlEventSet_t set) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlEventSetFree
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlEventSetFree(nvmlEventSet_t __pyx_v_set) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlEventSetFree", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6045
 * cdef nvmlReturn_t _nvmlEventSetFree(nvmlEventSet_t set) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlEventSetFree
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlEventSetFree == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6045, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6046
 *     global __nvmlEventSetFree
 *     _check_or_init_nvml()
 *     if __nvmlEventSetFree == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlEventSetFree is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlEventSetFree == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6047
 *     _check_or_init_nvml()
 *     if __nvmlEventSetFree == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlEventSetFree is not found")
 *     return (<nvmlReturn_t (*)(nvmlEventSet_t) noexcept nogil>__nvmlEventSetFree)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6048
 *     if __nvmlEventSetFree == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlEventSetFree is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlEventSet_t) noexcept nogil>__nvmlEventSetFree)(
 *         set)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6048, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlEventSetFree_is_not};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6048, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6048, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6047
 *     _check_or_init_nvml()
 *     if __nvmlEventSetFree == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlEventSetFree is not found")
 *     return (<nvmlReturn_t (*)(nvmlEventSet_t) noexcept nogil>__nvmlEventSetFree)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6046
 *     global __nvmlEventSetFree
 *     _check_or_init_nvml()
 *     if __nvmlEventSetFree == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlEventSetFree is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6049
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlEventSetFree is not found")
 *     return (<nvmlReturn_t (*)(nvmlEventSet_t) noexcept nogil>__nvmlEventSetFree)(             # <<<<<<<<<<<<<<
 *         set)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlEventSet_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlEventSetFree)(__pyx_v_set);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6043
 * 
 * 
 * cdef nvmlReturn_t _nvmlEventSetFree(nvmlEventSet_t set) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlEventSetFree
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlEventSetFree", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6053
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemEventSetCreate(nvmlSystemEventSetCreateRequest_t* request) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemEventSetCreate
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemEventSetCreate(nvmlSystemEventSetCreateRequest_t *__pyx_v_request) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlSystemEventSetCreate", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6055
 * cdef nvmlReturn_t _nvmlSystemEventSetCreate(nvmlSystemEventSetCreateRequest_t* request) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlSystemEventSetCreate
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlSystemEventSetCreate == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6055, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6056
 *     global __nvmlSystemEventSetCreate
 *     _check_or_init_nvml()
 *     if __nvmlSystemEventSetCreate == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemEventSetCreate is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemEventSetCreate == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6057
 *     _check_or_init_nvml()
 *     if __nvmlSystemEventSetCreate == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemEventSetCreate is not found")
 *     return (<nvmlReturn_t (*)(nvmlSystemEventSetCreateRequest_t*) noexcept nogil>__nvmlSystemEventSetCreate)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6058
 *     if __nvmlSystemEventSetCreate == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemEventSetCreate is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlSystemEventSetCreateRequest_t*) noexcept nogil>__nvmlSystemEventSetCreate)(
 *         request)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6058, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlSystemEventSetCreat};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6058, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6058, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6057
 *     _check_or_init_nvml()
 *     if __nvmlSystemEventSetCreate == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemEventSetCreate is not found")
 *     return (<nvmlReturn_t (*)(nvmlSystemEventSetCreateRequest_t*) noexcept nogil>__nvmlSystemEventSetCreate)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6056
 *     global __nvmlSystemEventSetCreate
 *     _check_or_init_nvml()
 *     if __nvmlSystemEventSetCreate == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemEventSetCreate is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6059
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemEventSetCreate is not found")
 *     return (<nvmlReturn_t (*)(nvmlSystemEventSetCreateRequest_t*) noexcept nogil>__nvmlSystemEventSetCreate)(             # <<<<<<<<<<<<<<
 *         request)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlSystemEventSetCreateRequest_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemEventSetCreate)(__pyx_v_request);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6053
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemEventSetCreate(nvmlSystemEventSetCreateRequest_t* request) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemEventSetCreate
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlSystemEventSetCreate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6063
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemEventSetFree(nvmlSystemEventSetFreeRequest_t* request) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemEventSetFree
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemEventSetFree(nvmlSystemEventSetFreeRequest_t *__pyx_v_request) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlSystemEventSetFree", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6065
 * cdef nvmlReturn_t _nvmlSystemEventSetFree(nvmlSystemEventSetFreeRequest_t* request) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlSystemEventSetFree
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlSystemEventSetFree == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6065, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6066
 *     global __nvmlSystemEventSetFree
 *     _check_or_init_nvml()
 *     if __nvmlSystemEventSetFree == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemEventSetFree is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemEventSetFree == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6067
 *     _check_or_init_nvml()
 *     if __nvmlSystemEventSetFree == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemEventSetFree is not found")
 *     return (<nvmlReturn_t (*)(nvmlSystemEventSetFreeRequest_t*) noexcept nogil>__nvmlSystemEventSetFree)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6068
 *     if __nvmlSystemEventSetFree == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemEventSetFree is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlSystemEventSetFreeRequest_t*) noexcept nogil>__nvmlSystemEventSetFree)(
 *         request)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6068, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlSystemEventSetFree};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6068, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6068, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6067
 *     _check_or_init_nvml()
 *     if __nvmlSystemEventSetFree == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemEventSetFree is not found")
 *     return (<nvmlReturn_t (*)(nvmlSystemEventSetFreeRequest_t*) noexcept nogil>__nvmlSystemEventSetFree)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6066
 *     global __nvmlSystemEventSetFree
 *     _check_or_init_nvml()
 *     if __nvmlSystemEventSetFree == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemEventSetFree is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6069
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemEventSetFree is not found")
 *     return (<nvmlReturn_t (*)(nvmlSystemEventSetFreeRequest_t*) noexcept nogil>__nvmlSystemEventSetFree)(             # <<<<<<<<<<<<<<
 *         request)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlSystemEventSetFreeRequest_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemEventSetFree)(__pyx_v_request);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6063
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemEventSetFree(nvmlSystemEventSetFreeRequest_t* request) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemEventSetFree
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlSystemEventSetFree", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6073
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemRegisterEvents(nvmlSystemRegisterEventRequest_t* request) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemRegisterEvents
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemRegisterEvents(nvmlSystemRegisterEventRequest_t *__pyx_v_request) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlSystemRegisterEvents", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6075
 * cdef nvmlReturn_t _nvmlSystemRegisterEvents(nvmlSystemRegisterEventRequest_t* request) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlSystemRegisterEvents
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlSystemRegisterEvents == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6075, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6076
 *     global __nvmlSystemRegisterEvents
 *     _check_or_init_nvml()
 *     if __nvmlSystemRegisterEvents == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemRegisterEvents is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemRegisterEvents == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6077
 *     _check_or_init_nvml()
 *     if __nvmlSystemRegisterEvents == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemRegisterEvents is not found")
 *     return (<nvmlReturn_t (*)(nvmlSystemRegisterEventRequest_t*) noexcept nogil>__nvmlSystemRegisterEvents)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6078
 *     if __nvmlSystemRegisterEvents == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemRegisterEvents is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlSystemRegisterEventRequest_t*) noexcept nogil>__nvmlSystemRegisterEvents)(
 *         request)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6078, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlSystemRegisterEvent};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6078, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6078, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6077
 *     _check_or_init_nvml()
 *     if __nvmlSystemRegisterEvents == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemRegisterEvents is not found")
 *     return (<nvmlReturn_t (*)(nvmlSystemRegisterEventRequest_t*) noexcept nogil>__nvmlSystemRegisterEvents)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6076
 *     global __nvmlSystemRegisterEvents
 *     _check_or_init_nvml()
 *     if __nvmlSystemRegisterEvents == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemRegisterEvents is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6079
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemRegisterEvents is not found")
 *     return (<nvmlReturn_t (*)(nvmlSystemRegisterEventRequest_t*) noexcept nogil>__nvmlSystemRegisterEvents)(             # <<<<<<<<<<<<<<
 *         request)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlSystemRegisterEventRequest_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemRegisterEvents)(__pyx_v_request);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6073
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemRegisterEvents(nvmlSystemRegisterEventRequest_t* request) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemRegisterEvents
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlSystemRegisterEvents", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6083
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemEventSetWait(nvmlSystemEventSetWaitRequest_t* request) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemEventSetWait
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemEventSetWait(nvmlSystemEventSetWaitRequest_t *__pyx_v_request) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlSystemEventSetWait", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6085
 * cdef nvmlReturn_t _nvmlSystemEventSetWait(nvmlSystemEventSetWaitRequest_t* request) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlSystemEventSetWait
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlSystemEventSetWait == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6085, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6086
 *     global __nvmlSystemEventSetWait
 *     _check_or_init_nvml()
 *     if __nvmlSystemEventSetWait == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemEventSetWait is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemEventSetWait == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6087
 *     _check_or_init_nvml()
 *     if __nvmlSystemEventSetWait == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemEventSetWait is not found")
 *     return (<nvmlReturn_t (*)(nvmlSystemEventSetWaitRequest_t*) noexcept nogil>__nvmlSystemEventSetWait)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6088
 *     if __nvmlSystemEventSetWait == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemEventSetWait is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlSystemEventSetWaitRequest_t*) noexcept nogil>__nvmlSystemEventSetWait)(
 *         request)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6088, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlSystemEventSetWait};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6088, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6088, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6087
 *     _check_or_init_nvml()
 *     if __nvmlSystemEventSetWait == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSystemEventSetWait is not found")
 *     return (<nvmlReturn_t (*)(nvmlSystemEventSetWaitRequest_t*) noexcept nogil>__nvmlSystemEventSetWait)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6086
 *     global __nvmlSystemEventSetWait
 *     _check_or_init_nvml()
 *     if __nvmlSystemEventSetWait == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemEventSetWait is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6089
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSystemEventSetWait is not found")
 *     return (<nvmlReturn_t (*)(nvmlSystemEventSetWaitRequest_t*) noexcept nogil>__nvmlSystemEventSetWait)(             # <<<<<<<<<<<<<<
 *         request)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlSystemEventSetWaitRequest_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemEventSetWait)(__pyx_v_request);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6083
 * 
 * 
 * cdef nvmlReturn_t _nvmlSystemEventSetWait(nvmlSystemEventSetWaitRequest_t* request) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSystemEventSetWait
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlSystemEventSetWait", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6093
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceModifyDrainState(nvmlPciInfo_t* pciInfo, nvmlEnableState_t newState) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceModifyDrainState
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceModifyDrainState(nvmlPciInfo_t *__pyx_v_pciInfo, nvmlEnableState_t __pyx_v_newState) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceModifyDrainState", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6095
 * cdef nvmlReturn_t _nvmlDeviceModifyDrainState(nvmlPciInfo_t* pciInfo, nvmlEnableState_t newState) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceModifyDrainState
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceModifyDrainState == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6095, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6096
 *     global __nvmlDeviceModifyDrainState
 *     _check_or_init_nvml()
 *     if __nvmlDeviceModifyDrainState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceModifyDrainState is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceModifyDrainState == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6097
 *     _check_or_init_nvml()
 *     if __nvmlDeviceModifyDrainState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceModifyDrainState is not found")
 *     return (<nvmlReturn_t (*)(nvmlPciInfo_t*, nvmlEnableState_t) noexcept nogil>__nvmlDeviceModifyDrainState)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6098
 *     if __nvmlDeviceModifyDrainState == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceModifyDrainState is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlPciInfo_t*, nvmlEnableState_t) noexcept nogil>__nvmlDeviceModifyDrainState)(
 *         pciInfo, newState)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6098, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceModifyDrainSt};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6098, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6098, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6097
 *     _check_or_init_nvml()
 *     if __nvmlDeviceModifyDrainState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceModifyDrainState is not found")
 *     return (<nvmlReturn_t (*)(nvmlPciInfo_t*, nvmlEnableState_t) noexcept nogil>__nvmlDeviceModifyDrainState)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6096
 *     global __nvmlDeviceModifyDrainState
 *     _check_or_init_nvml()
 *     if __nvmlDeviceModifyDrainState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceModifyDrainState is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6099
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceModifyDrainState is not found")
 *     return (<nvmlReturn_t (*)(nvmlPciInfo_t*, nvmlEnableState_t) noexcept nogil>__nvmlDeviceModifyDrainState)(             # <<<<<<<<<<<<<<
 *         pciInfo, newState)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlPciInfo_t *, nvmlEnableState_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceModifyDrainState)(__pyx_v_pciInfo, __pyx_v_newState);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6093
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceModifyDrainState(nvmlPciInfo_t* pciInfo, nvmlEnableState_t newState) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceModifyDrainState
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceModifyDrainState", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6103
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceQueryDrainState(nvmlPciInfo_t* pciInfo, nvmlEnableState_t* currentState) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceQueryDrainState
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceQueryDrainState(nvmlPciInfo_t *__pyx_v_pciInfo, nvmlEnableState_t *__pyx_v_currentState) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceQueryDrainState", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6105
 * cdef nvmlReturn_t _nvmlDeviceQueryDrainState(nvmlPciInfo_t* pciInfo, nvmlEnableState_t* currentState) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceQueryDrainState
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceQueryDrainState == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6105, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6106
 *     global __nvmlDeviceQueryDrainState
 *     _check_or_init_nvml()
 *     if __nvmlDeviceQueryDrainState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceQueryDrainState is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceQueryDrainState == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6107
 *     _check_or_init_nvml()
 *     if __nvmlDeviceQueryDrainState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceQueryDrainState is not found")
 *     return (<nvmlReturn_t (*)(nvmlPciInfo_t*, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceQueryDrainState)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6108
 *     if __nvmlDeviceQueryDrainState == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceQueryDrainState is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlPciInfo_t*, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceQueryDrainState)(
 *         pciInfo, currentState)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6108, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceQueryDrainSta};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6108, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6108, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6107
 *     _check_or_init_nvml()
 *     if __nvmlDeviceQueryDrainState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceQueryDrainState is not found")
 *     return (<nvmlReturn_t (*)(nvmlPciInfo_t*, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceQueryDrainState)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6106
 *     global __nvmlDeviceQueryDrainState
 *     _check_or_init_nvml()
 *     if __nvmlDeviceQueryDrainState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceQueryDrainState is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6109
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceQueryDrainState is not found")
 *     return (<nvmlReturn_t (*)(nvmlPciInfo_t*, nvmlEnableState_t*) noexcept nogil>__nvmlDeviceQueryDrainState)(             # <<<<<<<<<<<<<<
 *         pciInfo, currentState)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlPciInfo_t *, nvmlEnableState_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceQueryDrainState)(__pyx_v_pciInfo, __pyx_v_currentState);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6103
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceQueryDrainState(nvmlPciInfo_t* pciInfo, nvmlEnableState_t* currentState) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceQueryDrainState
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceQueryDrainState", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6113
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceRemoveGpu_v2(nvmlPciInfo_t* pciInfo, nvmlDetachGpuState_t gpuState, nvmlPcieLinkState_t linkState) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceRemoveGpu_v2
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceRemoveGpu_v2(nvmlPciInfo_t *__pyx_v_pciInfo, nvmlDetachGpuState_t __pyx_v_gpuState, nvmlPcieLinkState_t __pyx_v_linkState) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceRemoveGpu_v2", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6115
 * cdef nvmlReturn_t _nvmlDeviceRemoveGpu_v2(nvmlPciInfo_t* pciInfo, nvmlDetachGpuState_t gpuState, nvmlPcieLinkState_t linkState) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceRemoveGpu_v2
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceRemoveGpu_v2 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6115, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6116
 *     global __nvmlDeviceRemoveGpu_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceRemoveGpu_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceRemoveGpu_v2 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceRemoveGpu_v2 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6117
 *     _check_or_init_nvml()
 *     if __nvmlDeviceRemoveGpu_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceRemoveGpu_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlPciInfo_t*, nvmlDetachGpuState_t, nvmlPcieLinkState_t) noexcept nogil>__nvmlDeviceRemoveGpu_v2)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6118
 *     if __nvmlDeviceRemoveGpu_v2 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceRemoveGpu_v2 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlPciInfo_t*, nvmlDetachGpuState_t, nvmlPcieLinkState_t) noexcept nogil>__nvmlDeviceRemoveGpu_v2)(
 *         pciInfo, gpuState, linkState)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6118, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceRemoveGpu_v2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6118, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6118, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6117
 *     _check_or_init_nvml()
 *     if __nvmlDeviceRemoveGpu_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceRemoveGpu_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlPciInfo_t*, nvmlDetachGpuState_t, nvmlPcieLinkState_t) noexcept nogil>__nvmlDeviceRemoveGpu_v2)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6116
 *     global __nvmlDeviceRemoveGpu_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceRemoveGpu_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceRemoveGpu_v2 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6119
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceRemoveGpu_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlPciInfo_t*, nvmlDetachGpuState_t, nvmlPcieLinkState_t) noexcept nogil>__nvmlDeviceRemoveGpu_v2)(             # <<<<<<<<<<<<<<
 *         pciInfo, gpuState, linkState)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlPciInfo_t *, nvmlDetachGpuState_t, nvmlPcieLinkState_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceRemoveGpu_v2)(__pyx_v_pciInfo, __pyx_v_gpuState, __pyx_v_linkState);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6113
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceRemoveGpu_v2(nvmlPciInfo_t* pciInfo, nvmlDetachGpuState_t gpuState, nvmlPcieLinkState_t linkState) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceRemoveGpu_v2
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceRemoveGpu_v2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6123
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceDiscoverGpus(nvmlPciInfo_t* pciInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceDiscoverGpus
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceDiscoverGpus(nvmlPciInfo_t *__pyx_v_pciInfo) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceDiscoverGpus", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6125
 * cdef nvmlReturn_t _nvmlDeviceDiscoverGpus(nvmlPciInfo_t* pciInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceDiscoverGpus
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceDiscoverGpus == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6125, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6126
 *     global __nvmlDeviceDiscoverGpus
 *     _check_or_init_nvml()
 *     if __nvmlDeviceDiscoverGpus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceDiscoverGpus is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceDiscoverGpus == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6127
 *     _check_or_init_nvml()
 *     if __nvmlDeviceDiscoverGpus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceDiscoverGpus is not found")
 *     return (<nvmlReturn_t (*)(nvmlPciInfo_t*) noexcept nogil>__nvmlDeviceDiscoverGpus)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6128
 *     if __nvmlDeviceDiscoverGpus == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceDiscoverGpus is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlPciInfo_t*) noexcept nogil>__nvmlDeviceDiscoverGpus)(
 *         pciInfo)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6128, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceDiscoverGpus};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6128, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6128, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6127
 *     _check_or_init_nvml()
 *     if __nvmlDeviceDiscoverGpus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceDiscoverGpus is not found")
 *     return (<nvmlReturn_t (*)(nvmlPciInfo_t*) noexcept nogil>__nvmlDeviceDiscoverGpus)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6126
 *     global __nvmlDeviceDiscoverGpus
 *     _check_or_init_nvml()
 *     if __nvmlDeviceDiscoverGpus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceDiscoverGpus is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6129
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceDiscoverGpus is not found")
 *     return (<nvmlReturn_t (*)(nvmlPciInfo_t*) noexcept nogil>__nvmlDeviceDiscoverGpus)(             # <<<<<<<<<<<<<<
 *         pciInfo)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlPciInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceDiscoverGpus)(__pyx_v_pciInfo);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6123
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceDiscoverGpus(nvmlPciInfo_t* pciInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceDiscoverGpus
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceDiscoverGpus", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6133
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetFieldValues(nvmlDevice_t device, int valuesCount, nvmlFieldValue_t* values) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetFieldValues
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetFieldValues(nvmlDevice_t __pyx_v_device, int __pyx_v_valuesCount, nvmlFieldValue_t *__pyx_v_values) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetFieldValues", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6135
 * cdef nvmlReturn_t _nvmlDeviceGetFieldValues(nvmlDevice_t device, int valuesCount, nvmlFieldValue_t* values) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetFieldValues
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetFieldValues == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6135, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6136
 *     global __nvmlDeviceGetFieldValues
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFieldValues == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFieldValues is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFieldValues == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6137
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFieldValues == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetFieldValues is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int, nvmlFieldValue_t*) noexcept nogil>__nvmlDeviceGetFieldValues)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6138
 *     if __nvmlDeviceGetFieldValues == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFieldValues is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int, nvmlFieldValue_t*) noexcept nogil>__nvmlDeviceGetFieldValues)(
 *         device, valuesCount, values)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6138, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetFieldValue};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6138, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6138, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6137
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFieldValues == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetFieldValues is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int, nvmlFieldValue_t*) noexcept nogil>__nvmlDeviceGetFieldValues)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6136
 *     global __nvmlDeviceGetFieldValues
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetFieldValues == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFieldValues is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6139
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetFieldValues is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int, nvmlFieldValue_t*) noexcept nogil>__nvmlDeviceGetFieldValues)(             # <<<<<<<<<<<<<<
 *         device, valuesCount, values)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, int, nvmlFieldValue_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFieldValues)(__pyx_v_device, __pyx_v_valuesCount, __pyx_v_values);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6133
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetFieldValues(nvmlDevice_t device, int valuesCount, nvmlFieldValue_t* values) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetFieldValues
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetFieldValues", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6143
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceClearFieldValues(nvmlDevice_t device, int valuesCount, nvmlFieldValue_t* values) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceClearFieldValues
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceClearFieldValues(nvmlDevice_t __pyx_v_device, int __pyx_v_valuesCount, nvmlFieldValue_t *__pyx_v_values) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceClearFieldValues", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6145
 * cdef nvmlReturn_t _nvmlDeviceClearFieldValues(nvmlDevice_t device, int valuesCount, nvmlFieldValue_t* values) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceClearFieldValues
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceClearFieldValues == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6145, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6146
 *     global __nvmlDeviceClearFieldValues
 *     _check_or_init_nvml()
 *     if __nvmlDeviceClearFieldValues == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceClearFieldValues is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearFieldValues == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6147
 *     _check_or_init_nvml()
 *     if __nvmlDeviceClearFieldValues == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceClearFieldValues is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int, nvmlFieldValue_t*) noexcept nogil>__nvmlDeviceClearFieldValues)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6148
 *     if __nvmlDeviceClearFieldValues == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceClearFieldValues is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int, nvmlFieldValue_t*) noexcept nogil>__nvmlDeviceClearFieldValues)(
 *         device, valuesCount, values)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6148, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceClearFieldVal};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6148, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6148, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6147
 *     _check_or_init_nvml()
 *     if __nvmlDeviceClearFieldValues == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceClearFieldValues is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int, nvmlFieldValue_t*) noexcept nogil>__nvmlDeviceClearFieldValues)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6146
 *     global __nvmlDeviceClearFieldValues
 *     _check_or_init_nvml()
 *     if __nvmlDeviceClearFieldValues == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceClearFieldValues is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6149
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceClearFieldValues is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, int, nvmlFieldValue_t*) noexcept nogil>__nvmlDeviceClearFieldValues)(             # <<<<<<<<<<<<<<
 *         device, valuesCount, values)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, int, nvmlFieldValue_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearFieldValues)(__pyx_v_device, __pyx_v_valuesCount, __pyx_v_values);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6143
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceClearFieldValues(nvmlDevice_t device, int valuesCount, nvmlFieldValue_t* values) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceClearFieldValues
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceClearFieldValues", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6153
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVirtualizationMode(nvmlDevice_t device, nvmlGpuVirtualizationMode_t* pVirtualMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVirtualizationMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVirtualizationMode(nvmlDevice_t __pyx_v_device, nvmlGpuVirtualizationMode_t *__pyx_v_pVirtualMode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetVirtualizationMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6155
 * cdef nvmlReturn_t _nvmlDeviceGetVirtualizationMode(nvmlDevice_t device, nvmlGpuVirtualizationMode_t* pVirtualMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetVirtualizationMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetVirtualizationMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6155, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6156
 *     global __nvmlDeviceGetVirtualizationMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVirtualizationMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVirtualizationMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVirtualizationMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6157
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVirtualizationMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVirtualizationMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuVirtualizationMode_t*) noexcept nogil>__nvmlDeviceGetVirtualizationMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6158
 *     if __nvmlDeviceGetVirtualizationMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVirtualizationMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuVirtualizationMode_t*) noexcept nogil>__nvmlDeviceGetVirtualizationMode)(
 *         device, pVirtualMode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6158, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetVirtualiza};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6158, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6158, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6157
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVirtualizationMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVirtualizationMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuVirtualizationMode_t*) noexcept nogil>__nvmlDeviceGetVirtualizationMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6156
 *     global __nvmlDeviceGetVirtualizationMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVirtualizationMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVirtualizationMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6159
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVirtualizationMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuVirtualizationMode_t*) noexcept nogil>__nvmlDeviceGetVirtualizationMode)(             # <<<<<<<<<<<<<<
 *         device, pVirtualMode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuVirtualizationMode_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVirtualizationMode)(__pyx_v_device, __pyx_v_pVirtualMode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6153
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVirtualizationMode(nvmlDevice_t device, nvmlGpuVirtualizationMode_t* pVirtualMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVirtualizationMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetVirtualizationMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6163
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetHostVgpuMode(nvmlDevice_t device, nvmlHostVgpuMode_t* pHostVgpuMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetHostVgpuMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetHostVgpuMode(nvmlDevice_t __pyx_v_device, nvmlHostVgpuMode_t *__pyx_v_pHostVgpuMode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetHostVgpuMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6165
 * cdef nvmlReturn_t _nvmlDeviceGetHostVgpuMode(nvmlDevice_t device, nvmlHostVgpuMode_t* pHostVgpuMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetHostVgpuMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetHostVgpuMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6165, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6166
 *     global __nvmlDeviceGetHostVgpuMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHostVgpuMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHostVgpuMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHostVgpuMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6167
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHostVgpuMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetHostVgpuMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlHostVgpuMode_t*) noexcept nogil>__nvmlDeviceGetHostVgpuMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6168
 *     if __nvmlDeviceGetHostVgpuMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHostVgpuMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlHostVgpuMode_t*) noexcept nogil>__nvmlDeviceGetHostVgpuMode)(
 *         device, pHostVgpuMode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6168, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetHostVgpuMo};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6168, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6168, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6167
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHostVgpuMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetHostVgpuMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlHostVgpuMode_t*) noexcept nogil>__nvmlDeviceGetHostVgpuMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6166
 *     global __nvmlDeviceGetHostVgpuMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHostVgpuMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHostVgpuMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6169
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHostVgpuMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlHostVgpuMode_t*) noexcept nogil>__nvmlDeviceGetHostVgpuMode)(             # <<<<<<<<<<<<<<
 *         device, pHostVgpuMode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlHostVgpuMode_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHostVgpuMode)(__pyx_v_device, __pyx_v_pHostVgpuMode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6163
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetHostVgpuMode(nvmlDevice_t device, nvmlHostVgpuMode_t* pHostVgpuMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetHostVgpuMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetHostVgpuMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6173
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetVirtualizationMode(nvmlDevice_t device, nvmlGpuVirtualizationMode_t virtualMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetVirtualizationMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetVirtualizationMode(nvmlDevice_t __pyx_v_device, nvmlGpuVirtualizationMode_t __pyx_v_virtualMode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetVirtualizationMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6175
 * cdef nvmlReturn_t _nvmlDeviceSetVirtualizationMode(nvmlDevice_t device, nvmlGpuVirtualizationMode_t virtualMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetVirtualizationMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetVirtualizationMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6175, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6176
 *     global __nvmlDeviceSetVirtualizationMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetVirtualizationMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetVirtualizationMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVirtualizationMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6177
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetVirtualizationMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetVirtualizationMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuVirtualizationMode_t) noexcept nogil>__nvmlDeviceSetVirtualizationMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6178
 *     if __nvmlDeviceSetVirtualizationMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetVirtualizationMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuVirtualizationMode_t) noexcept nogil>__nvmlDeviceSetVirtualizationMode)(
 *         device, virtualMode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6178, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetVirtualiza};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6178, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6178, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6177
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetVirtualizationMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetVirtualizationMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuVirtualizationMode_t) noexcept nogil>__nvmlDeviceSetVirtualizationMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6176
 *     global __nvmlDeviceSetVirtualizationMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetVirtualizationMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetVirtualizationMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6179
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetVirtualizationMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuVirtualizationMode_t) noexcept nogil>__nvmlDeviceSetVirtualizationMode)(             # <<<<<<<<<<<<<<
 *         device, virtualMode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlGpuVirtualizationMode_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVirtualizationMode)(__pyx_v_device, __pyx_v_virtualMode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6173
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetVirtualizationMode(nvmlDevice_t device, nvmlGpuVirtualizationMode_t virtualMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetVirtualizationMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetVirtualizationMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6183
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuHeterogeneousMode(nvmlDevice_t device, nvmlVgpuHeterogeneousMode_t* pHeterogeneousMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVgpuHeterogeneousMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVgpuHeterogeneousMode(nvmlDevice_t __pyx_v_device, nvmlVgpuHeterogeneousMode_t *__pyx_v_pHeterogeneousMode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetVgpuHeterogeneousMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6185
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuHeterogeneousMode(nvmlDevice_t device, nvmlVgpuHeterogeneousMode_t* pHeterogeneousMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetVgpuHeterogeneousMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetVgpuHeterogeneousMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6185, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6186
 *     global __nvmlDeviceGetVgpuHeterogeneousMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuHeterogeneousMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuHeterogeneousMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuHeterogeneousMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6187
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuHeterogeneousMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuHeterogeneousMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuHeterogeneousMode_t*) noexcept nogil>__nvmlDeviceGetVgpuHeterogeneousMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6188
 *     if __nvmlDeviceGetVgpuHeterogeneousMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuHeterogeneousMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuHeterogeneousMode_t*) noexcept nogil>__nvmlDeviceGetVgpuHeterogeneousMode)(
 *         device, pHeterogeneousMode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6188, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetVgpuHetero};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6188, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6188, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6187
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuHeterogeneousMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuHeterogeneousMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuHeterogeneousMode_t*) noexcept nogil>__nvmlDeviceGetVgpuHeterogeneousMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6186
 *     global __nvmlDeviceGetVgpuHeterogeneousMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuHeterogeneousMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuHeterogeneousMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6189
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuHeterogeneousMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuHeterogeneousMode_t*) noexcept nogil>__nvmlDeviceGetVgpuHeterogeneousMode)(             # <<<<<<<<<<<<<<
 *         device, pHeterogeneousMode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuHeterogeneousMode_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuHeterogeneousMode)(__pyx_v_device, __pyx_v_pHeterogeneousMode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6183
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuHeterogeneousMode(nvmlDevice_t device, nvmlVgpuHeterogeneousMode_t* pHeterogeneousMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVgpuHeterogeneousMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetVgpuHeterogeneousMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6193
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetVgpuHeterogeneousMode(nvmlDevice_t device, const nvmlVgpuHeterogeneousMode_t* pHeterogeneousMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetVgpuHeterogeneousMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetVgpuHeterogeneousMode(nvmlDevice_t __pyx_v_device, nvmlVgpuHeterogeneousMode_t const *__pyx_v_pHeterogeneousMode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetVgpuHeterogeneousMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6195
 * cdef nvmlReturn_t _nvmlDeviceSetVgpuHeterogeneousMode(nvmlDevice_t device, const nvmlVgpuHeterogeneousMode_t* pHeterogeneousMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetVgpuHeterogeneousMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetVgpuHeterogeneousMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6195, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6196
 *     global __nvmlDeviceSetVgpuHeterogeneousMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetVgpuHeterogeneousMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetVgpuHeterogeneousMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVgpuHeterogeneousMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6197
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetVgpuHeterogeneousMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetVgpuHeterogeneousMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, const nvmlVgpuHeterogeneousMode_t*) noexcept nogil>__nvmlDeviceSetVgpuHeterogeneousMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6198
 *     if __nvmlDeviceSetVgpuHeterogeneousMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetVgpuHeterogeneousMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, const nvmlVgpuHeterogeneousMode_t*) noexcept nogil>__nvmlDeviceSetVgpuHeterogeneousMode)(
 *         device, pHeterogeneousMode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6198, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetVgpuHetero};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6198, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6198, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6197
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetVgpuHeterogeneousMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetVgpuHeterogeneousMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, const nvmlVgpuHeterogeneousMode_t*) noexcept nogil>__nvmlDeviceSetVgpuHeterogeneousMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6196
 *     global __nvmlDeviceSetVgpuHeterogeneousMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetVgpuHeterogeneousMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetVgpuHeterogeneousMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6199
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetVgpuHeterogeneousMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, const nvmlVgpuHeterogeneousMode_t*) noexcept nogil>__nvmlDeviceSetVgpuHeterogeneousMode)(             # <<<<<<<<<<<<<<
 *         device, pHeterogeneousMode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuHeterogeneousMode_t const *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVgpuHeterogeneousMode)(__pyx_v_device, __pyx_v_pHeterogeneousMode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6193
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetVgpuHeterogeneousMode(nvmlDevice_t device, const nvmlVgpuHeterogeneousMode_t* pHeterogeneousMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetVgpuHeterogeneousMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetVgpuHeterogeneousMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6203
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetPlacementId(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuPlacementId_t* pPlacement) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetPlacementId
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetPlacementId(nvmlVgpuInstance_t __pyx_v_vgpuInstance, nvmlVgpuPlacementId_t *__pyx_v_pPlacement) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceGetPlacementId", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6205
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetPlacementId(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuPlacementId_t* pPlacement) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceGetPlacementId
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceGetPlacementId == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6205, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6206
 *     global __nvmlVgpuInstanceGetPlacementId
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetPlacementId == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetPlacementId is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetPlacementId == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6207
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetPlacementId == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetPlacementId is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuPlacementId_t*) noexcept nogil>__nvmlVgpuInstanceGetPlacementId)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6208
 *     if __nvmlVgpuInstanceGetPlacementId == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetPlacementId is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuPlacementId_t*) noexcept nogil>__nvmlVgpuInstanceGetPlacementId)(
 *         vgpuInstance, pPlacement)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6208, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceGetPlac};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6208, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6208, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6207
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetPlacementId == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetPlacementId is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuPlacementId_t*) noexcept nogil>__nvmlVgpuInstanceGetPlacementId)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6206
 *     global __nvmlVgpuInstanceGetPlacementId
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetPlacementId == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetPlacementId is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6209
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetPlacementId is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuPlacementId_t*) noexcept nogil>__nvmlVgpuInstanceGetPlacementId)(             # <<<<<<<<<<<<<<
 *         vgpuInstance, pPlacement)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuPlacementId_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetPlacementId)(__pyx_v_vgpuInstance, __pyx_v_pPlacement);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6203
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetPlacementId(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuPlacementId_t* pPlacement) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetPlacementId
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceGetPlacementId", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6213
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuTypeSupportedPlacements(nvmlDevice_t device, nvmlVgpuTypeId_t vgpuTypeId, nvmlVgpuPlacementList_t* pPlacementList) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVgpuTypeSupportedPlacements
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVgpuTypeSupportedPlacements(nvmlDevice_t __pyx_v_device, nvmlVgpuTypeId_t __pyx_v_vgpuTypeId, nvmlVgpuPlacementList_t *__pyx_v_pPlacementList) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetVgpuTypeSupportedPlacements", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6215
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuTypeSupportedPlacements(nvmlDevice_t device, nvmlVgpuTypeId_t vgpuTypeId, nvmlVgpuPlacementList_t* pPlacementList) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetVgpuTypeSupportedPlacements
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetVgpuTypeSupportedPlacements == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6215, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6216
 *     global __nvmlDeviceGetVgpuTypeSupportedPlacements
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuTypeSupportedPlacements == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuTypeSupportedPlacements is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuTypeSupportedPlacements == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6217
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuTypeSupportedPlacements == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuTypeSupportedPlacements is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuTypeId_t, nvmlVgpuPlacementList_t*) noexcept nogil>__nvmlDeviceGetVgpuTypeSupportedPlacements)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6218
 *     if __nvmlDeviceGetVgpuTypeSupportedPlacements == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuTypeSupportedPlacements is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuTypeId_t, nvmlVgpuPlacementList_t*) noexcept nogil>__nvmlDeviceGetVgpuTypeSupportedPlacements)(
 *         device, vgpuTypeId, pPlacementList)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6218, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetVgpuTypeSu};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6218, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6218, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6217
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuTypeSupportedPlacements == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuTypeSupportedPlacements is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuTypeId_t, nvmlVgpuPlacementList_t*) noexcept nogil>__nvmlDeviceGetVgpuTypeSupportedPlacements)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6216
 *     global __nvmlDeviceGetVgpuTypeSupportedPlacements
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuTypeSupportedPlacements == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuTypeSupportedPlacements is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6219
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuTypeSupportedPlacements is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuTypeId_t, nvmlVgpuPlacementList_t*) noexcept nogil>__nvmlDeviceGetVgpuTypeSupportedPlacements)(             # <<<<<<<<<<<<<<
 *         device, vgpuTypeId, pPlacementList)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuTypeId_t, nvmlVgpuPlacementList_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuTypeSupportedPlacements)(__pyx_v_device, __pyx_v_vgpuTypeId, __pyx_v_pPlacementList);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6213
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuTypeSupportedPlacements(nvmlDevice_t device, nvmlVgpuTypeId_t vgpuTypeId, nvmlVgpuPlacementList_t* pPlacementList) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVgpuTypeSupportedPlacements
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetVgpuTypeSupportedPlacements", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6223
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuTypeCreatablePlacements(nvmlDevice_t device, nvmlVgpuTypeId_t vgpuTypeId, nvmlVgpuPlacementList_t* pPlacementList) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVgpuTypeCreatablePlacements
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVgpuTypeCreatablePlacements(nvmlDevice_t __pyx_v_device, nvmlVgpuTypeId_t __pyx_v_vgpuTypeId, nvmlVgpuPlacementList_t *__pyx_v_pPlacementList) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetVgpuTypeCreatablePlacements", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6225
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuTypeCreatablePlacements(nvmlDevice_t device, nvmlVgpuTypeId_t vgpuTypeId, nvmlVgpuPlacementList_t* pPlacementList) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetVgpuTypeCreatablePlacements
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetVgpuTypeCreatablePlacements == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6225, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6226
 *     global __nvmlDeviceGetVgpuTypeCreatablePlacements
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuTypeCreatablePlacements == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuTypeCreatablePlacements is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuTypeCreatablePlacements == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6227
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuTypeCreatablePlacements == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuTypeCreatablePlacements is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuTypeId_t, nvmlVgpuPlacementList_t*) noexcept nogil>__nvmlDeviceGetVgpuTypeCreatablePlacements)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6228
 *     if __nvmlDeviceGetVgpuTypeCreatablePlacements == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuTypeCreatablePlacements is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuTypeId_t, nvmlVgpuPlacementList_t*) noexcept nogil>__nvmlDeviceGetVgpuTypeCreatablePlacements)(
 *         device, vgpuTypeId, pPlacementList)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6228, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetVgpuTypeCr};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6228, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6228, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6227
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuTypeCreatablePlacements == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuTypeCreatablePlacements is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuTypeId_t, nvmlVgpuPlacementList_t*) noexcept nogil>__nvmlDeviceGetVgpuTypeCreatablePlacements)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6226
 *     global __nvmlDeviceGetVgpuTypeCreatablePlacements
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuTypeCreatablePlacements == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuTypeCreatablePlacements is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6229
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuTypeCreatablePlacements is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuTypeId_t, nvmlVgpuPlacementList_t*) noexcept nogil>__nvmlDeviceGetVgpuTypeCreatablePlacements)(             # <<<<<<<<<<<<<<
 *         device, vgpuTypeId, pPlacementList)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuTypeId_t, nvmlVgpuPlacementList_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuTypeCreatablePlacements)(__pyx_v_device, __pyx_v_vgpuTypeId, __pyx_v_pPlacementList);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6223
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuTypeCreatablePlacements(nvmlDevice_t device, nvmlVgpuTypeId_t vgpuTypeId, nvmlVgpuPlacementList_t* pPlacementList) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVgpuTypeCreatablePlacements
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetVgpuTypeCreatablePlacements", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6233
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetGspHeapSize(nvmlVgpuTypeId_t vgpuTypeId, unsigned long long* gspHeapSize) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetGspHeapSize
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetGspHeapSize(nvmlVgpuTypeId_t __pyx_v_vgpuTypeId, unsigned PY_LONG_LONG *__pyx_v_gspHeapSize) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuTypeGetGspHeapSize", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6235
 * cdef nvmlReturn_t _nvmlVgpuTypeGetGspHeapSize(nvmlVgpuTypeId_t vgpuTypeId, unsigned long long* gspHeapSize) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuTypeGetGspHeapSize
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuTypeGetGspHeapSize == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6235, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6236
 *     global __nvmlVgpuTypeGetGspHeapSize
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetGspHeapSize == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetGspHeapSize is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetGspHeapSize == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6237
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetGspHeapSize == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetGspHeapSize is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned long long*) noexcept nogil>__nvmlVgpuTypeGetGspHeapSize)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6238
 *     if __nvmlVgpuTypeGetGspHeapSize == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetGspHeapSize is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned long long*) noexcept nogil>__nvmlVgpuTypeGetGspHeapSize)(
 *         vgpuTypeId, gspHeapSize)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6238, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuTypeGetGspHeapS};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6238, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6238, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6237
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetGspHeapSize == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetGspHeapSize is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned long long*) noexcept nogil>__nvmlVgpuTypeGetGspHeapSize)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6236
 *     global __nvmlVgpuTypeGetGspHeapSize
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetGspHeapSize == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetGspHeapSize is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6239
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetGspHeapSize is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned long long*) noexcept nogil>__nvmlVgpuTypeGetGspHeapSize)(             # <<<<<<<<<<<<<<
 *         vgpuTypeId, gspHeapSize)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned PY_LONG_LONG *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetGspHeapSize)(__pyx_v_vgpuTypeId, __pyx_v_gspHeapSize);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6233
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetGspHeapSize(nvmlVgpuTypeId_t vgpuTypeId, unsigned long long* gspHeapSize) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetGspHeapSize
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuTypeGetGspHeapSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6243
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetFbReservation(nvmlVgpuTypeId_t vgpuTypeId, unsigned long long* fbReservation) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetFbReservation
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetFbReservation(nvmlVgpuTypeId_t __pyx_v_vgpuTypeId, unsigned PY_LONG_LONG *__pyx_v_fbReservation) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuTypeGetFbReservation", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6245
 * cdef nvmlReturn_t _nvmlVgpuTypeGetFbReservation(nvmlVgpuTypeId_t vgpuTypeId, unsigned long long* fbReservation) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuTypeGetFbReservation
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuTypeGetFbReservation == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6245, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6246
 *     global __nvmlVgpuTypeGetFbReservation
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetFbReservation == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetFbReservation is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetFbReservation == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6247
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetFbReservation == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetFbReservation is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned long long*) noexcept nogil>__nvmlVgpuTypeGetFbReservation)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6248
 *     if __nvmlVgpuTypeGetFbReservation == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetFbReservation is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned long long*) noexcept nogil>__nvmlVgpuTypeGetFbReservation)(
 *         vgpuTypeId, fbReservation)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6248, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuTypeGetFbReserv};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6248, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6248, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6247
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetFbReservation == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetFbReservation is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned long long*) noexcept nogil>__nvmlVgpuTypeGetFbReservation)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6246
 *     global __nvmlVgpuTypeGetFbReservation
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetFbReservation == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetFbReservation is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6249
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetFbReservation is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned long long*) noexcept nogil>__nvmlVgpuTypeGetFbReservation)(             # <<<<<<<<<<<<<<
 *         vgpuTypeId, fbReservation)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned PY_LONG_LONG *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetFbReservation)(__pyx_v_vgpuTypeId, __pyx_v_fbReservation);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6243
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetFbReservation(nvmlVgpuTypeId_t vgpuTypeId, unsigned long long* fbReservation) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetFbReservation
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuTypeGetFbReservation", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6253
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetRuntimeStateSize(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuRuntimeState_t* pState) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetRuntimeStateSize
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetRuntimeStateSize(nvmlVgpuInstance_t __pyx_v_vgpuInstance, nvmlVgpuRuntimeState_t *__pyx_v_pState) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceGetRuntimeStateSize", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6255
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetRuntimeStateSize(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuRuntimeState_t* pState) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceGetRuntimeStateSize
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceGetRuntimeStateSize == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6255, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6256
 *     global __nvmlVgpuInstanceGetRuntimeStateSize
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetRuntimeStateSize == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetRuntimeStateSize is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetRuntimeStateSize == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6257
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetRuntimeStateSize == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetRuntimeStateSize is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuRuntimeState_t*) noexcept nogil>__nvmlVgpuInstanceGetRuntimeStateSize)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6258
 *     if __nvmlVgpuInstanceGetRuntimeStateSize == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetRuntimeStateSize is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuRuntimeState_t*) noexcept nogil>__nvmlVgpuInstanceGetRuntimeStateSize)(
 *         vgpuInstance, pState)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6258, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceGetRunt};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6258, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6258, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6257
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetRuntimeStateSize == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetRuntimeStateSize is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuRuntimeState_t*) noexcept nogil>__nvmlVgpuInstanceGetRuntimeStateSize)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6256
 *     global __nvmlVgpuInstanceGetRuntimeStateSize
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetRuntimeStateSize == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetRuntimeStateSize is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6259
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetRuntimeStateSize is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuRuntimeState_t*) noexcept nogil>__nvmlVgpuInstanceGetRuntimeStateSize)(             # <<<<<<<<<<<<<<
 *         vgpuInstance, pState)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuRuntimeState_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetRuntimeStateSize)(__pyx_v_vgpuInstance, __pyx_v_pState);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6253
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetRuntimeStateSize(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuRuntimeState_t* pState) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetRuntimeStateSize
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceGetRuntimeStateSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6263
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetVgpuCapabilities(nvmlDevice_t device, nvmlDeviceVgpuCapability_t capability, nvmlEnableState_t state) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetVgpuCapabilities
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetVgpuCapabilities(nvmlDevice_t __pyx_v_device, nvmlDeviceVgpuCapability_t __pyx_v_capability, nvmlEnableState_t __pyx_v_state) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetVgpuCapabilities", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6265
 * cdef nvmlReturn_t _nvmlDeviceSetVgpuCapabilities(nvmlDevice_t device, nvmlDeviceVgpuCapability_t capability, nvmlEnableState_t state) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetVgpuCapabilities
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetVgpuCapabilities == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6265, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6266
 *     global __nvmlDeviceSetVgpuCapabilities
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetVgpuCapabilities == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetVgpuCapabilities is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVgpuCapabilities == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6267
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetVgpuCapabilities == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetVgpuCapabilities is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceVgpuCapability_t, nvmlEnableState_t) noexcept nogil>__nvmlDeviceSetVgpuCapabilities)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6268
 *     if __nvmlDeviceSetVgpuCapabilities == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetVgpuCapabilities is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceVgpuCapability_t, nvmlEnableState_t) noexcept nogil>__nvmlDeviceSetVgpuCapabilities)(
 *         device, capability, state)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6268, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetVgpuCapabi};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6268, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6268, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6267
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetVgpuCapabilities == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetVgpuCapabilities is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceVgpuCapability_t, nvmlEnableState_t) noexcept nogil>__nvmlDeviceSetVgpuCapabilities)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6266
 *     global __nvmlDeviceSetVgpuCapabilities
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetVgpuCapabilities == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetVgpuCapabilities is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6269
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetVgpuCapabilities is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceVgpuCapability_t, nvmlEnableState_t) noexcept nogil>__nvmlDeviceSetVgpuCapabilities)(             # <<<<<<<<<<<<<<
 *         device, capability, state)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceVgpuCapability_t, nvmlEnableState_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVgpuCapabilities)(__pyx_v_device, __pyx_v_capability, __pyx_v_state);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6263
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetVgpuCapabilities(nvmlDevice_t device, nvmlDeviceVgpuCapability_t capability, nvmlEnableState_t state) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetVgpuCapabilities
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetVgpuCapabilities", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6273
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGridLicensableFeatures_v4(nvmlDevice_t device, nvmlGridLicensableFeatures_t* pGridLicensableFeatures) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGridLicensableFeatures_v4
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGridLicensableFeatures_v4(nvmlDevice_t __pyx_v_device, nvmlGridLicensableFeatures_t *__pyx_v_pGridLicensableFeatures) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetGridLicensableFeatures_v4", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6275
 * cdef nvmlReturn_t _nvmlDeviceGetGridLicensableFeatures_v4(nvmlDevice_t device, nvmlGridLicensableFeatures_t* pGridLicensableFeatures) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetGridLicensableFeatures_v4
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetGridLicensableFeatures_v4 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6275, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6276
 *     global __nvmlDeviceGetGridLicensableFeatures_v4
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGridLicensableFeatures_v4 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGridLicensableFeatures_v4 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGridLicensableFeatures_v4 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6277
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGridLicensableFeatures_v4 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGridLicensableFeatures_v4 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGridLicensableFeatures_t*) noexcept nogil>__nvmlDeviceGetGridLicensableFeatures_v4)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6278
 *     if __nvmlDeviceGetGridLicensableFeatures_v4 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGridLicensableFeatures_v4 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGridLicensableFeatures_t*) noexcept nogil>__nvmlDeviceGetGridLicensableFeatures_v4)(
 *         device, pGridLicensableFeatures)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6278, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetGridLicens};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6278, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6278, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6277
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGridLicensableFeatures_v4 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGridLicensableFeatures_v4 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGridLicensableFeatures_t*) noexcept nogil>__nvmlDeviceGetGridLicensableFeatures_v4)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6276
 *     global __nvmlDeviceGetGridLicensableFeatures_v4
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGridLicensableFeatures_v4 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGridLicensableFeatures_v4 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6279
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGridLicensableFeatures_v4 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGridLicensableFeatures_t*) noexcept nogil>__nvmlDeviceGetGridLicensableFeatures_v4)(             # <<<<<<<<<<<<<<
 *         device, pGridLicensableFeatures)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlGridLicensableFeatures_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGridLicensableFeatures_v4)(__pyx_v_device, __pyx_v_pGridLicensableFeatures);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6273
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGridLicensableFeatures_v4(nvmlDevice_t device, nvmlGridLicensableFeatures_t* pGridLicensableFeatures) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGridLicensableFeatures_v4
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetGridLicensableFeatures_v4", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6283
 * 
 * 
 * cdef nvmlReturn_t _nvmlGetVgpuDriverCapabilities(nvmlVgpuDriverCapability_t capability, unsigned int* capResult) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGetVgpuDriverCapabilities
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGetVgpuDriverCapabilities(nvmlVgpuDriverCapability_t __pyx_v_capability, unsigned int *__pyx_v_capResult) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGetVgpuDriverCapabilities", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6285
 * cdef nvmlReturn_t _nvmlGetVgpuDriverCapabilities(nvmlVgpuDriverCapability_t capability, unsigned int* capResult) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGetVgpuDriverCapabilities
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGetVgpuDriverCapabilities == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6285, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6286
 *     global __nvmlGetVgpuDriverCapabilities
 *     _check_or_init_nvml()
 *     if __nvmlGetVgpuDriverCapabilities == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGetVgpuDriverCapabilities is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetVgpuDriverCapabilities == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6287
 *     _check_or_init_nvml()
 *     if __nvmlGetVgpuDriverCapabilities == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGetVgpuDriverCapabilities is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuDriverCapability_t, unsigned int*) noexcept nogil>__nvmlGetVgpuDriverCapabilities)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6288
 *     if __nvmlGetVgpuDriverCapabilities == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGetVgpuDriverCapabilities is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuDriverCapability_t, unsigned int*) noexcept nogil>__nvmlGetVgpuDriverCapabilities)(
 *         capability, capResult)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6288, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGetVgpuDriverCapabi};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6288, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6288, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6287
 *     _check_or_init_nvml()
 *     if __nvmlGetVgpuDriverCapabilities == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGetVgpuDriverCapabilities is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuDriverCapability_t, unsigned int*) noexcept nogil>__nvmlGetVgpuDriverCapabilities)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6286
 *     global __nvmlGetVgpuDriverCapabilities
 *     _check_or_init_nvml()
 *     if __nvmlGetVgpuDriverCapabilities == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGetVgpuDriverCapabilities is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6289
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGetVgpuDriverCapabilities is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuDriverCapability_t, unsigned int*) noexcept nogil>__nvmlGetVgpuDriverCapabilities)(             # <<<<<<<<<<<<<<
 *         capability, capResult)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuDriverCapability_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetVgpuDriverCapabilities)(__pyx_v_capability, __pyx_v_capResult);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6283
 * 
 * 
 * cdef nvmlReturn_t _nvmlGetVgpuDriverCapabilities(nvmlVgpuDriverCapability_t capability, unsigned int* capResult) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGetVgpuDriverCapabilities
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGetVgpuDriverCapabilities", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6293
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuCapabilities(nvmlDevice_t device, nvmlDeviceVgpuCapability_t capability, unsigned int* capResult) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVgpuCapabilities
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVgpuCapabilities(nvmlDevice_t __pyx_v_device, nvmlDeviceVgpuCapability_t __pyx_v_capability, unsigned int *__pyx_v_capResult) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetVgpuCapabilities", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6295
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuCapabilities(nvmlDevice_t device, nvmlDeviceVgpuCapability_t capability, unsigned int* capResult) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetVgpuCapabilities
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetVgpuCapabilities == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6295, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6296
 *     global __nvmlDeviceGetVgpuCapabilities
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuCapabilities == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuCapabilities is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuCapabilities == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6297
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuCapabilities == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuCapabilities is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceVgpuCapability_t, unsigned int*) noexcept nogil>__nvmlDeviceGetVgpuCapabilities)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6298
 *     if __nvmlDeviceGetVgpuCapabilities == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuCapabilities is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceVgpuCapability_t, unsigned int*) noexcept nogil>__nvmlDeviceGetVgpuCapabilities)(
 *         device, capability, capResult)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6298, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetVgpuCapabi};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6298, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6298, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6297
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuCapabilities == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuCapabilities is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceVgpuCapability_t, unsigned int*) noexcept nogil>__nvmlDeviceGetVgpuCapabilities)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6296
 *     global __nvmlDeviceGetVgpuCapabilities
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuCapabilities == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuCapabilities is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6299
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuCapabilities is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceVgpuCapability_t, unsigned int*) noexcept nogil>__nvmlDeviceGetVgpuCapabilities)(             # <<<<<<<<<<<<<<
 *         device, capability, capResult)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceVgpuCapability_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuCapabilities)(__pyx_v_device, __pyx_v_capability, __pyx_v_capResult);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6293
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuCapabilities(nvmlDevice_t device, nvmlDeviceVgpuCapability_t capability, unsigned int* capResult) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVgpuCapabilities
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetVgpuCapabilities", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6303
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetSupportedVgpus(nvmlDevice_t device, unsigned int* vgpuCount, nvmlVgpuTypeId_t* vgpuTypeIds) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetSupportedVgpus
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetSupportedVgpus(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_vgpuCount, nvmlVgpuTypeId_t *__pyx_v_vgpuTypeIds) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetSupportedVgpus", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6305
 * cdef nvmlReturn_t _nvmlDeviceGetSupportedVgpus(nvmlDevice_t device, unsigned int* vgpuCount, nvmlVgpuTypeId_t* vgpuTypeIds) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetSupportedVgpus
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetSupportedVgpus == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6305, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6306
 *     global __nvmlDeviceGetSupportedVgpus
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSupportedVgpus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedVgpus is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedVgpus == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6307
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSupportedVgpus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedVgpus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlVgpuTypeId_t*) noexcept nogil>__nvmlDeviceGetSupportedVgpus)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6308
 *     if __nvmlDeviceGetSupportedVgpus == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedVgpus is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlVgpuTypeId_t*) noexcept nogil>__nvmlDeviceGetSupportedVgpus)(
 *         device, vgpuCount, vgpuTypeIds)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6308, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetSupportedV};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6308, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6308, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6307
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSupportedVgpus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedVgpus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlVgpuTypeId_t*) noexcept nogil>__nvmlDeviceGetSupportedVgpus)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6306
 *     global __nvmlDeviceGetSupportedVgpus
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSupportedVgpus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedVgpus is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6309
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSupportedVgpus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlVgpuTypeId_t*) noexcept nogil>__nvmlDeviceGetSupportedVgpus)(             # <<<<<<<<<<<<<<
 *         device, vgpuCount, vgpuTypeIds)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *, nvmlVgpuTypeId_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedVgpus)(__pyx_v_device, __pyx_v_vgpuCount, __pyx_v_vgpuTypeIds);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6303
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetSupportedVgpus(nvmlDevice_t device, unsigned int* vgpuCount, nvmlVgpuTypeId_t* vgpuTypeIds) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetSupportedVgpus
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetSupportedVgpus", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6313
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetCreatableVgpus(nvmlDevice_t device, unsigned int* vgpuCount, nvmlVgpuTypeId_t* vgpuTypeIds) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetCreatableVgpus
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetCreatableVgpus(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_vgpuCount, nvmlVgpuTypeId_t *__pyx_v_vgpuTypeIds) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetCreatableVgpus", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6315
 * cdef nvmlReturn_t _nvmlDeviceGetCreatableVgpus(nvmlDevice_t device, unsigned int* vgpuCount, nvmlVgpuTypeId_t* vgpuTypeIds) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetCreatableVgpus
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetCreatableVgpus == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6315, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6316
 *     global __nvmlDeviceGetCreatableVgpus
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCreatableVgpus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCreatableVgpus is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCreatableVgpus == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6317
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCreatableVgpus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetCreatableVgpus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlVgpuTypeId_t*) noexcept nogil>__nvmlDeviceGetCreatableVgpus)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6318
 *     if __nvmlDeviceGetCreatableVgpus == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCreatableVgpus is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlVgpuTypeId_t*) noexcept nogil>__nvmlDeviceGetCreatableVgpus)(
 *         device, vgpuCount, vgpuTypeIds)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6318, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetCreatableV};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6318, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6318, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6317
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCreatableVgpus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetCreatableVgpus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlVgpuTypeId_t*) noexcept nogil>__nvmlDeviceGetCreatableVgpus)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6316
 *     global __nvmlDeviceGetCreatableVgpus
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCreatableVgpus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCreatableVgpus is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6319
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCreatableVgpus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlVgpuTypeId_t*) noexcept nogil>__nvmlDeviceGetCreatableVgpus)(             # <<<<<<<<<<<<<<
 *         device, vgpuCount, vgpuTypeIds)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *, nvmlVgpuTypeId_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCreatableVgpus)(__pyx_v_device, __pyx_v_vgpuCount, __pyx_v_vgpuTypeIds);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6313
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetCreatableVgpus(nvmlDevice_t device, unsigned int* vgpuCount, nvmlVgpuTypeId_t* vgpuTypeIds) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetCreatableVgpus
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetCreatableVgpus", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6323
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetClass(nvmlVgpuTypeId_t vgpuTypeId, char* vgpuTypeClass, unsigned int* size) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetClass
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetClass(nvmlVgpuTypeId_t __pyx_v_vgpuTypeId, char *__pyx_v_vgpuTypeClass, unsigned int *__pyx_v_size) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuTypeGetClass", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6325
 * cdef nvmlReturn_t _nvmlVgpuTypeGetClass(nvmlVgpuTypeId_t vgpuTypeId, char* vgpuTypeClass, unsigned int* size) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuTypeGetClass
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuTypeGetClass == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6325, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6326
 *     global __nvmlVgpuTypeGetClass
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetClass == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetClass is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetClass == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6327
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetClass == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetClass is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, char*, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetClass)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6328
 *     if __nvmlVgpuTypeGetClass == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetClass is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, char*, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetClass)(
 *         vgpuTypeId, vgpuTypeClass, size)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6328, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuTypeGetClass_is};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6328, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6328, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6327
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetClass == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetClass is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, char*, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetClass)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6326
 *     global __nvmlVgpuTypeGetClass
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetClass == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetClass is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6329
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetClass is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, char*, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetClass)(             # <<<<<<<<<<<<<<
 *         vgpuTypeId, vgpuTypeClass, size)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuTypeId_t, char *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetClass)(__pyx_v_vgpuTypeId, __pyx_v_vgpuTypeClass, __pyx_v_size);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6323
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetClass(nvmlVgpuTypeId_t vgpuTypeId, char* vgpuTypeClass, unsigned int* size) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetClass
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuTypeGetClass", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6333
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetName(nvmlVgpuTypeId_t vgpuTypeId, char* vgpuTypeName, unsigned int* size) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetName
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetName(nvmlVgpuTypeId_t __pyx_v_vgpuTypeId, char *__pyx_v_vgpuTypeName, unsigned int *__pyx_v_size) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuTypeGetName", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6335
 * cdef nvmlReturn_t _nvmlVgpuTypeGetName(nvmlVgpuTypeId_t vgpuTypeId, char* vgpuTypeName, unsigned int* size) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuTypeGetName
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuTypeGetName == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6335, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6336
 *     global __nvmlVgpuTypeGetName
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetName == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetName is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetName == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6337
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetName == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetName is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, char*, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetName)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6338
 *     if __nvmlVgpuTypeGetName == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetName is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, char*, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetName)(
 *         vgpuTypeId, vgpuTypeName, size)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6338, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuTypeGetName_is};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6338, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6338, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6337
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetName == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetName is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, char*, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetName)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6336
 *     global __nvmlVgpuTypeGetName
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetName == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetName is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6339
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetName is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, char*, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetName)(             # <<<<<<<<<<<<<<
 *         vgpuTypeId, vgpuTypeName, size)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuTypeId_t, char *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetName)(__pyx_v_vgpuTypeId, __pyx_v_vgpuTypeName, __pyx_v_size);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6333
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetName(nvmlVgpuTypeId_t vgpuTypeId, char* vgpuTypeName, unsigned int* size) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetName
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuTypeGetName", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6343
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetGpuInstanceProfileId(nvmlVgpuTypeId_t vgpuTypeId, unsigned int* gpuInstanceProfileId) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetGpuInstanceProfileId
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetGpuInstanceProfileId(nvmlVgpuTypeId_t __pyx_v_vgpuTypeId, unsigned int *__pyx_v_gpuInstanceProfileId) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuTypeGetGpuInstanceProfileId", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6345
 * cdef nvmlReturn_t _nvmlVgpuTypeGetGpuInstanceProfileId(nvmlVgpuTypeId_t vgpuTypeId, unsigned int* gpuInstanceProfileId) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuTypeGetGpuInstanceProfileId
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuTypeGetGpuInstanceProfileId == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6345, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6346
 *     global __nvmlVgpuTypeGetGpuInstanceProfileId
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetGpuInstanceProfileId == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetGpuInstanceProfileId is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetGpuInstanceProfileId == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6347
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetGpuInstanceProfileId == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetGpuInstanceProfileId is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetGpuInstanceProfileId)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6348
 *     if __nvmlVgpuTypeGetGpuInstanceProfileId == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetGpuInstanceProfileId is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetGpuInstanceProfileId)(
 *         vgpuTypeId, gpuInstanceProfileId)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6348, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuTypeGetGpuInsta};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6348, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6348, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6347
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetGpuInstanceProfileId == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetGpuInstanceProfileId is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetGpuInstanceProfileId)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6346
 *     global __nvmlVgpuTypeGetGpuInstanceProfileId
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetGpuInstanceProfileId == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetGpuInstanceProfileId is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6349
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetGpuInstanceProfileId is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetGpuInstanceProfileId)(             # <<<<<<<<<<<<<<
 *         vgpuTypeId, gpuInstanceProfileId)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetGpuInstanceProfileId)(__pyx_v_vgpuTypeId, __pyx_v_gpuInstanceProfileId);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6343
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetGpuInstanceProfileId(nvmlVgpuTypeId_t vgpuTypeId, unsigned int* gpuInstanceProfileId) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetGpuInstanceProfileId
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuTypeGetGpuInstanceProfileId", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6353
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetDeviceID(nvmlVgpuTypeId_t vgpuTypeId, unsigned long long* deviceID, unsigned long long* subsystemID) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetDeviceID
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetDeviceID(nvmlVgpuTypeId_t __pyx_v_vgpuTypeId, unsigned PY_LONG_LONG *__pyx_v_deviceID, unsigned PY_LONG_LONG *__pyx_v_subsystemID) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuTypeGetDeviceID", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6355
 * cdef nvmlReturn_t _nvmlVgpuTypeGetDeviceID(nvmlVgpuTypeId_t vgpuTypeId, unsigned long long* deviceID, unsigned long long* subsystemID) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuTypeGetDeviceID
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuTypeGetDeviceID == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6355, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6356
 *     global __nvmlVgpuTypeGetDeviceID
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetDeviceID == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetDeviceID is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetDeviceID == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6357
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetDeviceID == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetDeviceID is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned long long*, unsigned long long*) noexcept nogil>__nvmlVgpuTypeGetDeviceID)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6358
 *     if __nvmlVgpuTypeGetDeviceID == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetDeviceID is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned long long*, unsigned long long*) noexcept nogil>__nvmlVgpuTypeGetDeviceID)(
 *         vgpuTypeId, deviceID, subsystemID)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6358, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuTypeGetDeviceID};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6358, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6358, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6357
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetDeviceID == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetDeviceID is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned long long*, unsigned long long*) noexcept nogil>__nvmlVgpuTypeGetDeviceID)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6356
 *     global __nvmlVgpuTypeGetDeviceID
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetDeviceID == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetDeviceID is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6359
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetDeviceID is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned long long*, unsigned long long*) noexcept nogil>__nvmlVgpuTypeGetDeviceID)(             # <<<<<<<<<<<<<<
 *         vgpuTypeId, deviceID, subsystemID)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned PY_LONG_LONG *, unsigned PY_LONG_LONG *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetDeviceID)(__pyx_v_vgpuTypeId, __pyx_v_deviceID, __pyx_v_subsystemID);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6353
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetDeviceID(nvmlVgpuTypeId_t vgpuTypeId, unsigned long long* deviceID, unsigned long long* subsystemID) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetDeviceID
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuTypeGetDeviceID", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6363
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetFramebufferSize(nvmlVgpuTypeId_t vgpuTypeId, unsigned long long* fbSize) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetFramebufferSize
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetFramebufferSize(nvmlVgpuTypeId_t __pyx_v_vgpuTypeId, unsigned PY_LONG_LONG *__pyx_v_fbSize) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuTypeGetFramebufferSize", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6365
 * cdef nvmlReturn_t _nvmlVgpuTypeGetFramebufferSize(nvmlVgpuTypeId_t vgpuTypeId, unsigned long long* fbSize) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuTypeGetFramebufferSize
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuTypeGetFramebufferSize == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6365, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6366
 *     global __nvmlVgpuTypeGetFramebufferSize
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetFramebufferSize == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetFramebufferSize is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetFramebufferSize == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6367
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetFramebufferSize == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetFramebufferSize is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned long long*) noexcept nogil>__nvmlVgpuTypeGetFramebufferSize)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6368
 *     if __nvmlVgpuTypeGetFramebufferSize == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetFramebufferSize is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned long long*) noexcept nogil>__nvmlVgpuTypeGetFramebufferSize)(
 *         vgpuTypeId, fbSize)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6368, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuTypeGetFramebuf};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6368, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6368, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6367
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetFramebufferSize == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetFramebufferSize is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned long long*) noexcept nogil>__nvmlVgpuTypeGetFramebufferSize)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6366
 *     global __nvmlVgpuTypeGetFramebufferSize
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetFramebufferSize == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetFramebufferSize is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6369
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetFramebufferSize is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned long long*) noexcept nogil>__nvmlVgpuTypeGetFramebufferSize)(             # <<<<<<<<<<<<<<
 *         vgpuTypeId, fbSize)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned PY_LONG_LONG *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetFramebufferSize)(__pyx_v_vgpuTypeId, __pyx_v_fbSize);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6363
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetFramebufferSize(nvmlVgpuTypeId_t vgpuTypeId, unsigned long long* fbSize) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetFramebufferSize
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuTypeGetFramebufferSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6373
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetNumDisplayHeads(nvmlVgpuTypeId_t vgpuTypeId, unsigned int* numDisplayHeads) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetNumDisplayHeads
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetNumDisplayHeads(nvmlVgpuTypeId_t __pyx_v_vgpuTypeId, unsigned int *__pyx_v_numDisplayHeads) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuTypeGetNumDisplayHeads", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6375
 * cdef nvmlReturn_t _nvmlVgpuTypeGetNumDisplayHeads(nvmlVgpuTypeId_t vgpuTypeId, unsigned int* numDisplayHeads) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuTypeGetNumDisplayHeads
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuTypeGetNumDisplayHeads == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6375, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6376
 *     global __nvmlVgpuTypeGetNumDisplayHeads
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetNumDisplayHeads == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetNumDisplayHeads is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetNumDisplayHeads == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6377
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetNumDisplayHeads == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetNumDisplayHeads is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetNumDisplayHeads)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6378
 *     if __nvmlVgpuTypeGetNumDisplayHeads == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetNumDisplayHeads is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetNumDisplayHeads)(
 *         vgpuTypeId, numDisplayHeads)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6378, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuTypeGetNumDispl};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6378, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6378, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6377
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetNumDisplayHeads == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetNumDisplayHeads is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetNumDisplayHeads)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6376
 *     global __nvmlVgpuTypeGetNumDisplayHeads
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetNumDisplayHeads == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetNumDisplayHeads is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6379
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetNumDisplayHeads is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetNumDisplayHeads)(             # <<<<<<<<<<<<<<
 *         vgpuTypeId, numDisplayHeads)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetNumDisplayHeads)(__pyx_v_vgpuTypeId, __pyx_v_numDisplayHeads);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6373
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetNumDisplayHeads(nvmlVgpuTypeId_t vgpuTypeId, unsigned int* numDisplayHeads) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetNumDisplayHeads
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuTypeGetNumDisplayHeads", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6383
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetResolution(nvmlVgpuTypeId_t vgpuTypeId, unsigned int displayIndex, unsigned int* xdim, unsigned int* ydim) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetResolution
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetResolution(nvmlVgpuTypeId_t __pyx_v_vgpuTypeId, unsigned int __pyx_v_displayIndex, unsigned int *__pyx_v_xdim, unsigned int *__pyx_v_ydim) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuTypeGetResolution", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6385
 * cdef nvmlReturn_t _nvmlVgpuTypeGetResolution(nvmlVgpuTypeId_t vgpuTypeId, unsigned int displayIndex, unsigned int* xdim, unsigned int* ydim) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuTypeGetResolution
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuTypeGetResolution == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6385, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6386
 *     global __nvmlVgpuTypeGetResolution
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetResolution == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetResolution is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetResolution == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6387
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetResolution == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetResolution is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int, unsigned int*, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetResolution)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6388
 *     if __nvmlVgpuTypeGetResolution == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetResolution is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int, unsigned int*, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetResolution)(
 *         vgpuTypeId, displayIndex, xdim, ydim)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6388, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuTypeGetResoluti};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6388, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6388, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6387
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetResolution == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetResolution is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int, unsigned int*, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetResolution)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6386
 *     global __nvmlVgpuTypeGetResolution
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetResolution == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetResolution is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6389
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetResolution is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int, unsigned int*, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetResolution)(             # <<<<<<<<<<<<<<
 *         vgpuTypeId, displayIndex, xdim, ydim)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int, unsigned int *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetResolution)(__pyx_v_vgpuTypeId, __pyx_v_displayIndex, __pyx_v_xdim, __pyx_v_ydim);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6383
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetResolution(nvmlVgpuTypeId_t vgpuTypeId, unsigned int displayIndex, unsigned int* xdim, unsigned int* ydim) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetResolution
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuTypeGetResolution", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6393
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetLicense(nvmlVgpuTypeId_t vgpuTypeId, char* vgpuTypeLicenseString, unsigned int size) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetLicense
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetLicense(nvmlVgpuTypeId_t __pyx_v_vgpuTypeId, char *__pyx_v_vgpuTypeLicenseString, unsigned int __pyx_v_size) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuTypeGetLicense", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6395
 * cdef nvmlReturn_t _nvmlVgpuTypeGetLicense(nvmlVgpuTypeId_t vgpuTypeId, char* vgpuTypeLicenseString, unsigned int size) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuTypeGetLicense
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuTypeGetLicense == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6395, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6396
 *     global __nvmlVgpuTypeGetLicense
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetLicense == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetLicense is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetLicense == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6397
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetLicense == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetLicense is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, char*, unsigned int) noexcept nogil>__nvmlVgpuTypeGetLicense)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6398
 *     if __nvmlVgpuTypeGetLicense == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetLicense is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, char*, unsigned int) noexcept nogil>__nvmlVgpuTypeGetLicense)(
 *         vgpuTypeId, vgpuTypeLicenseString, size)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6398, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuTypeGetLicense};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6398, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6398, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6397
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetLicense == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetLicense is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, char*, unsigned int) noexcept nogil>__nvmlVgpuTypeGetLicense)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6396
 *     global __nvmlVgpuTypeGetLicense
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetLicense == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetLicense is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6399
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetLicense is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, char*, unsigned int) noexcept nogil>__nvmlVgpuTypeGetLicense)(             # <<<<<<<<<<<<<<
 *         vgpuTypeId, vgpuTypeLicenseString, size)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuTypeId_t, char *, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetLicense)(__pyx_v_vgpuTypeId, __pyx_v_vgpuTypeLicenseString, __pyx_v_size);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6393
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetLicense(nvmlVgpuTypeId_t vgpuTypeId, char* vgpuTypeLicenseString, unsigned int size) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetLicense
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuTypeGetLicense", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6403
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetFrameRateLimit(nvmlVgpuTypeId_t vgpuTypeId, unsigned int* frameRateLimit) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetFrameRateLimit
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetFrameRateLimit(nvmlVgpuTypeId_t __pyx_v_vgpuTypeId, unsigned int *__pyx_v_frameRateLimit) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuTypeGetFrameRateLimit", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6405
 * cdef nvmlReturn_t _nvmlVgpuTypeGetFrameRateLimit(nvmlVgpuTypeId_t vgpuTypeId, unsigned int* frameRateLimit) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuTypeGetFrameRateLimit
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuTypeGetFrameRateLimit == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6405, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6406
 *     global __nvmlVgpuTypeGetFrameRateLimit
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetFrameRateLimit == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetFrameRateLimit is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetFrameRateLimit == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6407
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetFrameRateLimit == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetFrameRateLimit is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetFrameRateLimit)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6408
 *     if __nvmlVgpuTypeGetFrameRateLimit == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetFrameRateLimit is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetFrameRateLimit)(
 *         vgpuTypeId, frameRateLimit)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6408, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuTypeGetFrameRat};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6408, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6408, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6407
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetFrameRateLimit == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetFrameRateLimit is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetFrameRateLimit)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6406
 *     global __nvmlVgpuTypeGetFrameRateLimit
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetFrameRateLimit == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetFrameRateLimit is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6409
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetFrameRateLimit is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetFrameRateLimit)(             # <<<<<<<<<<<<<<
 *         vgpuTypeId, frameRateLimit)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetFrameRateLimit)(__pyx_v_vgpuTypeId, __pyx_v_frameRateLimit);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6403
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetFrameRateLimit(nvmlVgpuTypeId_t vgpuTypeId, unsigned int* frameRateLimit) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetFrameRateLimit
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuTypeGetFrameRateLimit", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6413
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetMaxInstances(nvmlDevice_t device, nvmlVgpuTypeId_t vgpuTypeId, unsigned int* vgpuInstanceCount) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetMaxInstances
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetMaxInstances(nvmlDevice_t __pyx_v_device, nvmlVgpuTypeId_t __pyx_v_vgpuTypeId, unsigned int *__pyx_v_vgpuInstanceCount) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuTypeGetMaxInstances", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6415
 * cdef nvmlReturn_t _nvmlVgpuTypeGetMaxInstances(nvmlDevice_t device, nvmlVgpuTypeId_t vgpuTypeId, unsigned int* vgpuInstanceCount) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuTypeGetMaxInstances
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuTypeGetMaxInstances == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6415, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6416
 *     global __nvmlVgpuTypeGetMaxInstances
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetMaxInstances == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetMaxInstances is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetMaxInstances == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6417
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetMaxInstances == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetMaxInstances is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuTypeId_t, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetMaxInstances)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6418
 *     if __nvmlVgpuTypeGetMaxInstances == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetMaxInstances is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuTypeId_t, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetMaxInstances)(
 *         device, vgpuTypeId, vgpuInstanceCount)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6418, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuTypeGetMaxInsta};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6418, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6418, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6417
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetMaxInstances == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetMaxInstances is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuTypeId_t, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetMaxInstances)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6416
 *     global __nvmlVgpuTypeGetMaxInstances
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetMaxInstances == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetMaxInstances is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6419
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetMaxInstances is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuTypeId_t, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetMaxInstances)(             # <<<<<<<<<<<<<<
 *         device, vgpuTypeId, vgpuInstanceCount)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuTypeId_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetMaxInstances)(__pyx_v_device, __pyx_v_vgpuTypeId, __pyx_v_vgpuInstanceCount);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6413
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetMaxInstances(nvmlDevice_t device, nvmlVgpuTypeId_t vgpuTypeId, unsigned int* vgpuInstanceCount) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetMaxInstances
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuTypeGetMaxInstances", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6423
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetMaxInstancesPerVm(nvmlVgpuTypeId_t vgpuTypeId, unsigned int* vgpuInstanceCountPerVm) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetMaxInstancesPerVm
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetMaxInstancesPerVm(nvmlVgpuTypeId_t __pyx_v_vgpuTypeId, unsigned int *__pyx_v_vgpuInstanceCountPerVm) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuTypeGetMaxInstancesPerVm", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6425
 * cdef nvmlReturn_t _nvmlVgpuTypeGetMaxInstancesPerVm(nvmlVgpuTypeId_t vgpuTypeId, unsigned int* vgpuInstanceCountPerVm) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuTypeGetMaxInstancesPerVm
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuTypeGetMaxInstancesPerVm == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6425, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6426
 *     global __nvmlVgpuTypeGetMaxInstancesPerVm
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetMaxInstancesPerVm == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetMaxInstancesPerVm is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetMaxInstancesPerVm == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6427
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetMaxInstancesPerVm == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetMaxInstancesPerVm is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetMaxInstancesPerVm)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6428
 *     if __nvmlVgpuTypeGetMaxInstancesPerVm == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetMaxInstancesPerVm is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetMaxInstancesPerVm)(
 *         vgpuTypeId, vgpuInstanceCountPerVm)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6428, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuTypeGetMaxInsta_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6428, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6428, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6427
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetMaxInstancesPerVm == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetMaxInstancesPerVm is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetMaxInstancesPerVm)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6426
 *     global __nvmlVgpuTypeGetMaxInstancesPerVm
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetMaxInstancesPerVm == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetMaxInstancesPerVm is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6429
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetMaxInstancesPerVm is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetMaxInstancesPerVm)(             # <<<<<<<<<<<<<<
 *         vgpuTypeId, vgpuInstanceCountPerVm)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuTypeId_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetMaxInstancesPerVm)(__pyx_v_vgpuTypeId, __pyx_v_vgpuInstanceCountPerVm);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6423
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetMaxInstancesPerVm(nvmlVgpuTypeId_t vgpuTypeId, unsigned int* vgpuInstanceCountPerVm) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetMaxInstancesPerVm
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuTypeGetMaxInstancesPerVm", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6433
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetBAR1Info(nvmlVgpuTypeId_t vgpuTypeId, nvmlVgpuTypeBar1Info_t* bar1Info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetBAR1Info
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetBAR1Info(nvmlVgpuTypeId_t __pyx_v_vgpuTypeId, nvmlVgpuTypeBar1Info_t *__pyx_v_bar1Info) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuTypeGetBAR1Info", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6435
 * cdef nvmlReturn_t _nvmlVgpuTypeGetBAR1Info(nvmlVgpuTypeId_t vgpuTypeId, nvmlVgpuTypeBar1Info_t* bar1Info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuTypeGetBAR1Info
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuTypeGetBAR1Info == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6435, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6436
 *     global __nvmlVgpuTypeGetBAR1Info
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetBAR1Info == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetBAR1Info is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetBAR1Info == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6437
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetBAR1Info == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetBAR1Info is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, nvmlVgpuTypeBar1Info_t*) noexcept nogil>__nvmlVgpuTypeGetBAR1Info)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6438
 *     if __nvmlVgpuTypeGetBAR1Info == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetBAR1Info is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, nvmlVgpuTypeBar1Info_t*) noexcept nogil>__nvmlVgpuTypeGetBAR1Info)(
 *         vgpuTypeId, bar1Info)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6438, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuTypeGetBAR1Info};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6438, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6438, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6437
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetBAR1Info == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetBAR1Info is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, nvmlVgpuTypeBar1Info_t*) noexcept nogil>__nvmlVgpuTypeGetBAR1Info)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6436
 *     global __nvmlVgpuTypeGetBAR1Info
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetBAR1Info == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetBAR1Info is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6439
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetBAR1Info is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, nvmlVgpuTypeBar1Info_t*) noexcept nogil>__nvmlVgpuTypeGetBAR1Info)(             # <<<<<<<<<<<<<<
 *         vgpuTypeId, bar1Info)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuTypeId_t, nvmlVgpuTypeBar1Info_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetBAR1Info)(__pyx_v_vgpuTypeId, __pyx_v_bar1Info);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6433
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetBAR1Info(nvmlVgpuTypeId_t vgpuTypeId, nvmlVgpuTypeBar1Info_t* bar1Info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetBAR1Info
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuTypeGetBAR1Info", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6443
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetActiveVgpus(nvmlDevice_t device, unsigned int* vgpuCount, nvmlVgpuInstance_t* vgpuInstances) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetActiveVgpus
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetActiveVgpus(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_vgpuCount, nvmlVgpuInstance_t *__pyx_v_vgpuInstances) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetActiveVgpus", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6445
 * cdef nvmlReturn_t _nvmlDeviceGetActiveVgpus(nvmlDevice_t device, unsigned int* vgpuCount, nvmlVgpuInstance_t* vgpuInstances) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetActiveVgpus
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetActiveVgpus == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6445, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6446
 *     global __nvmlDeviceGetActiveVgpus
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetActiveVgpus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetActiveVgpus is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetActiveVgpus == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6447
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetActiveVgpus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetActiveVgpus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlVgpuInstance_t*) noexcept nogil>__nvmlDeviceGetActiveVgpus)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6448
 *     if __nvmlDeviceGetActiveVgpus == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetActiveVgpus is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlVgpuInstance_t*) noexcept nogil>__nvmlDeviceGetActiveVgpus)(
 *         device, vgpuCount, vgpuInstances)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6448, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetActiveVgpu};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6448, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6448, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6447
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetActiveVgpus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetActiveVgpus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlVgpuInstance_t*) noexcept nogil>__nvmlDeviceGetActiveVgpus)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6446
 *     global __nvmlDeviceGetActiveVgpus
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetActiveVgpus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetActiveVgpus is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6449
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetActiveVgpus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, nvmlVgpuInstance_t*) noexcept nogil>__nvmlDeviceGetActiveVgpus)(             # <<<<<<<<<<<<<<
 *         device, vgpuCount, vgpuInstances)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *, nvmlVgpuInstance_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetActiveVgpus)(__pyx_v_device, __pyx_v_vgpuCount, __pyx_v_vgpuInstances);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6443
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetActiveVgpus(nvmlDevice_t device, unsigned int* vgpuCount, nvmlVgpuInstance_t* vgpuInstances) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetActiveVgpus
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetActiveVgpus", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6453
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetVmID(nvmlVgpuInstance_t vgpuInstance, char* vmId, unsigned int size, nvmlVgpuVmIdType_t* vmIdType) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetVmID
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetVmID(nvmlVgpuInstance_t __pyx_v_vgpuInstance, char *__pyx_v_vmId, unsigned int __pyx_v_size, nvmlVgpuVmIdType_t *__pyx_v_vmIdType) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceGetVmID", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6455
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetVmID(nvmlVgpuInstance_t vgpuInstance, char* vmId, unsigned int size, nvmlVgpuVmIdType_t* vmIdType) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceGetVmID
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceGetVmID == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6455, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6456
 *     global __nvmlVgpuInstanceGetVmID
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetVmID == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetVmID is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetVmID == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6457
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetVmID == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetVmID is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, char*, unsigned int, nvmlVgpuVmIdType_t*) noexcept nogil>__nvmlVgpuInstanceGetVmID)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6458
 *     if __nvmlVgpuInstanceGetVmID == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetVmID is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, char*, unsigned int, nvmlVgpuVmIdType_t*) noexcept nogil>__nvmlVgpuInstanceGetVmID)(
 *         vgpuInstance, vmId, size, vmIdType)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6458, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceGetVmID};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6458, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6458, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6457
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetVmID == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetVmID is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, char*, unsigned int, nvmlVgpuVmIdType_t*) noexcept nogil>__nvmlVgpuInstanceGetVmID)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6456
 *     global __nvmlVgpuInstanceGetVmID
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetVmID == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetVmID is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6459
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetVmID is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, char*, unsigned int, nvmlVgpuVmIdType_t*) noexcept nogil>__nvmlVgpuInstanceGetVmID)(             # <<<<<<<<<<<<<<
 *         vgpuInstance, vmId, size, vmIdType)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t, char *, unsigned int, nvmlVgpuVmIdType_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetVmID)(__pyx_v_vgpuInstance, __pyx_v_vmId, __pyx_v_size, __pyx_v_vmIdType);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6453
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetVmID(nvmlVgpuInstance_t vgpuInstance, char* vmId, unsigned int size, nvmlVgpuVmIdType_t* vmIdType) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetVmID
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceGetVmID", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6463
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetUUID(nvmlVgpuInstance_t vgpuInstance, char* uuid, unsigned int size) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetUUID
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetUUID(nvmlVgpuInstance_t __pyx_v_vgpuInstance, char *__pyx_v_uuid, unsigned int __pyx_v_size) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceGetUUID", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6465
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetUUID(nvmlVgpuInstance_t vgpuInstance, char* uuid, unsigned int size) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceGetUUID
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceGetUUID == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6465, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6466
 *     global __nvmlVgpuInstanceGetUUID
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetUUID == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetUUID is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetUUID == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6467
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetUUID == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetUUID is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, char*, unsigned int) noexcept nogil>__nvmlVgpuInstanceGetUUID)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6468
 *     if __nvmlVgpuInstanceGetUUID == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetUUID is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, char*, unsigned int) noexcept nogil>__nvmlVgpuInstanceGetUUID)(
 *         vgpuInstance, uuid, size)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6468, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceGetUUID};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6468, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6468, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6467
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetUUID == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetUUID is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, char*, unsigned int) noexcept nogil>__nvmlVgpuInstanceGetUUID)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6466
 *     global __nvmlVgpuInstanceGetUUID
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetUUID == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetUUID is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6469
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetUUID is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, char*, unsigned int) noexcept nogil>__nvmlVgpuInstanceGetUUID)(             # <<<<<<<<<<<<<<
 *         vgpuInstance, uuid, size)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t, char *, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetUUID)(__pyx_v_vgpuInstance, __pyx_v_uuid, __pyx_v_size);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6463
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetUUID(nvmlVgpuInstance_t vgpuInstance, char* uuid, unsigned int size) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetUUID
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceGetUUID", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6473
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetVmDriverVersion(nvmlVgpuInstance_t vgpuInstance, char* version, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetVmDriverVersion
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetVmDriverVersion(nvmlVgpuInstance_t __pyx_v_vgpuInstance, char *__pyx_v_version, unsigned int __pyx_v_length) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceGetVmDriverVersion", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6475
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetVmDriverVersion(nvmlVgpuInstance_t vgpuInstance, char* version, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceGetVmDriverVersion
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceGetVmDriverVersion == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6475, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6476
 *     global __nvmlVgpuInstanceGetVmDriverVersion
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetVmDriverVersion == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetVmDriverVersion is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetVmDriverVersion == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6477
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetVmDriverVersion == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetVmDriverVersion is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, char*, unsigned int) noexcept nogil>__nvmlVgpuInstanceGetVmDriverVersion)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6478
 *     if __nvmlVgpuInstanceGetVmDriverVersion == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetVmDriverVersion is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, char*, unsigned int) noexcept nogil>__nvmlVgpuInstanceGetVmDriverVersion)(
 *         vgpuInstance, version, length)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6478, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceGetVmDr};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6478, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6478, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6477
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetVmDriverVersion == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetVmDriverVersion is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, char*, unsigned int) noexcept nogil>__nvmlVgpuInstanceGetVmDriverVersion)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6476
 *     global __nvmlVgpuInstanceGetVmDriverVersion
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetVmDriverVersion == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetVmDriverVersion is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6479
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetVmDriverVersion is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, char*, unsigned int) noexcept nogil>__nvmlVgpuInstanceGetVmDriverVersion)(             # <<<<<<<<<<<<<<
 *         vgpuInstance, version, length)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t, char *, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetVmDriverVersion)(__pyx_v_vgpuInstance, __pyx_v_version, __pyx_v_length);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6473
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetVmDriverVersion(nvmlVgpuInstance_t vgpuInstance, char* version, unsigned int length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetVmDriverVersion
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceGetVmDriverVersion", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6483
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetFbUsage(nvmlVgpuInstance_t vgpuInstance, unsigned long long* fbUsage) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetFbUsage
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetFbUsage(nvmlVgpuInstance_t __pyx_v_vgpuInstance, unsigned PY_LONG_LONG *__pyx_v_fbUsage) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceGetFbUsage", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6485
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetFbUsage(nvmlVgpuInstance_t vgpuInstance, unsigned long long* fbUsage) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceGetFbUsage
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceGetFbUsage == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6485, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6486
 *     global __nvmlVgpuInstanceGetFbUsage
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetFbUsage == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetFbUsage is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFbUsage == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6487
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetFbUsage == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetFbUsage is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned long long*) noexcept nogil>__nvmlVgpuInstanceGetFbUsage)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6488
 *     if __nvmlVgpuInstanceGetFbUsage == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetFbUsage is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned long long*) noexcept nogil>__nvmlVgpuInstanceGetFbUsage)(
 *         vgpuInstance, fbUsage)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6488, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceGetFbUs};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6488, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6488, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6487
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetFbUsage == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetFbUsage is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned long long*) noexcept nogil>__nvmlVgpuInstanceGetFbUsage)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6486
 *     global __nvmlVgpuInstanceGetFbUsage
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetFbUsage == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetFbUsage is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6489
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetFbUsage is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned long long*) noexcept nogil>__nvmlVgpuInstanceGetFbUsage)(             # <<<<<<<<<<<<<<
 *         vgpuInstance, fbUsage)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned PY_LONG_LONG *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFbUsage)(__pyx_v_vgpuInstance, __pyx_v_fbUsage);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6483
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetFbUsage(nvmlVgpuInstance_t vgpuInstance, unsigned long long* fbUsage) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetFbUsage
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceGetFbUsage", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6493
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetLicenseStatus(nvmlVgpuInstance_t vgpuInstance, unsigned int* licensed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetLicenseStatus
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetLicenseStatus(nvmlVgpuInstance_t __pyx_v_vgpuInstance, unsigned int *__pyx_v_licensed) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceGetLicenseStatus", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6495
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetLicenseStatus(nvmlVgpuInstance_t vgpuInstance, unsigned int* licensed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceGetLicenseStatus
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceGetLicenseStatus == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6495, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6496
 *     global __nvmlVgpuInstanceGetLicenseStatus
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetLicenseStatus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetLicenseStatus is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetLicenseStatus == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6497
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetLicenseStatus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetLicenseStatus is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetLicenseStatus)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6498
 *     if __nvmlVgpuInstanceGetLicenseStatus == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetLicenseStatus is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetLicenseStatus)(
 *         vgpuInstance, licensed)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6498, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceGetLice};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6498, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6498, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6497
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetLicenseStatus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetLicenseStatus is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetLicenseStatus)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6496
 *     global __nvmlVgpuInstanceGetLicenseStatus
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetLicenseStatus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetLicenseStatus is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6499
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetLicenseStatus is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetLicenseStatus)(             # <<<<<<<<<<<<<<
 *         vgpuInstance, licensed)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetLicenseStatus)(__pyx_v_vgpuInstance, __pyx_v_licensed);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6493
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetLicenseStatus(nvmlVgpuInstance_t vgpuInstance, unsigned int* licensed) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetLicenseStatus
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceGetLicenseStatus", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6503
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetType(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuTypeId_t* vgpuTypeId) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetType
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetType(nvmlVgpuInstance_t __pyx_v_vgpuInstance, nvmlVgpuTypeId_t *__pyx_v_vgpuTypeId) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceGetType", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6505
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetType(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuTypeId_t* vgpuTypeId) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceGetType
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceGetType == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6505, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6506
 *     global __nvmlVgpuInstanceGetType
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetType == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetType is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetType == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6507
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetType == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetType is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuTypeId_t*) noexcept nogil>__nvmlVgpuInstanceGetType)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6508
 *     if __nvmlVgpuInstanceGetType == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetType is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuTypeId_t*) noexcept nogil>__nvmlVgpuInstanceGetType)(
 *         vgpuInstance, vgpuTypeId)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6508, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceGetType};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6508, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6508, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6507
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetType == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetType is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuTypeId_t*) noexcept nogil>__nvmlVgpuInstanceGetType)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6506
 *     global __nvmlVgpuInstanceGetType
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetType == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetType is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6509
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetType is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuTypeId_t*) noexcept nogil>__nvmlVgpuInstanceGetType)(             # <<<<<<<<<<<<<<
 *         vgpuInstance, vgpuTypeId)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuTypeId_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetType)(__pyx_v_vgpuInstance, __pyx_v_vgpuTypeId);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6503
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetType(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuTypeId_t* vgpuTypeId) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetType
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceGetType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6513
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetFrameRateLimit(nvmlVgpuInstance_t vgpuInstance, unsigned int* frameRateLimit) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetFrameRateLimit
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetFrameRateLimit(nvmlVgpuInstance_t __pyx_v_vgpuInstance, unsigned int *__pyx_v_frameRateLimit) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceGetFrameRateLimit", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6515
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetFrameRateLimit(nvmlVgpuInstance_t vgpuInstance, unsigned int* frameRateLimit) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceGetFrameRateLimit
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceGetFrameRateLimit == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6515, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6516
 *     global __nvmlVgpuInstanceGetFrameRateLimit
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetFrameRateLimit == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetFrameRateLimit is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFrameRateLimit == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6517
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetFrameRateLimit == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetFrameRateLimit is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetFrameRateLimit)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6518
 *     if __nvmlVgpuInstanceGetFrameRateLimit == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetFrameRateLimit is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetFrameRateLimit)(
 *         vgpuInstance, frameRateLimit)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6518, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceGetFram};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6518, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6518, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6517
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetFrameRateLimit == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetFrameRateLimit is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetFrameRateLimit)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6516
 *     global __nvmlVgpuInstanceGetFrameRateLimit
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetFrameRateLimit == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetFrameRateLimit is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6519
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetFrameRateLimit is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetFrameRateLimit)(             # <<<<<<<<<<<<<<
 *         vgpuInstance, frameRateLimit)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFrameRateLimit)(__pyx_v_vgpuInstance, __pyx_v_frameRateLimit);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6513
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetFrameRateLimit(nvmlVgpuInstance_t vgpuInstance, unsigned int* frameRateLimit) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetFrameRateLimit
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceGetFrameRateLimit", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6523
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetEccMode(nvmlVgpuInstance_t vgpuInstance, nvmlEnableState_t* eccMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetEccMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetEccMode(nvmlVgpuInstance_t __pyx_v_vgpuInstance, nvmlEnableState_t *__pyx_v_eccMode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceGetEccMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6525
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetEccMode(nvmlVgpuInstance_t vgpuInstance, nvmlEnableState_t* eccMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceGetEccMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceGetEccMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6525, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6526
 *     global __nvmlVgpuInstanceGetEccMode
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetEccMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetEccMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEccMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6527
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetEccMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetEccMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlEnableState_t*) noexcept nogil>__nvmlVgpuInstanceGetEccMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6528
 *     if __nvmlVgpuInstanceGetEccMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetEccMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlEnableState_t*) noexcept nogil>__nvmlVgpuInstanceGetEccMode)(
 *         vgpuInstance, eccMode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6528, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceGetEccM};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6528, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6528, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6527
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetEccMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetEccMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlEnableState_t*) noexcept nogil>__nvmlVgpuInstanceGetEccMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6526
 *     global __nvmlVgpuInstanceGetEccMode
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetEccMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetEccMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6529
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetEccMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlEnableState_t*) noexcept nogil>__nvmlVgpuInstanceGetEccMode)(             # <<<<<<<<<<<<<<
 *         vgpuInstance, eccMode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlEnableState_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEccMode)(__pyx_v_vgpuInstance, __pyx_v_eccMode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6523
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetEccMode(nvmlVgpuInstance_t vgpuInstance, nvmlEnableState_t* eccMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetEccMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceGetEccMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6533
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetEncoderCapacity(nvmlVgpuInstance_t vgpuInstance, unsigned int* encoderCapacity) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetEncoderCapacity
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetEncoderCapacity(nvmlVgpuInstance_t __pyx_v_vgpuInstance, unsigned int *__pyx_v_encoderCapacity) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceGetEncoderCapacity", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6535
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetEncoderCapacity(nvmlVgpuInstance_t vgpuInstance, unsigned int* encoderCapacity) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceGetEncoderCapacity
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceGetEncoderCapacity == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6535, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6536
 *     global __nvmlVgpuInstanceGetEncoderCapacity
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetEncoderCapacity == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetEncoderCapacity is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEncoderCapacity == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6537
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetEncoderCapacity == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetEncoderCapacity is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetEncoderCapacity)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6538
 *     if __nvmlVgpuInstanceGetEncoderCapacity == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetEncoderCapacity is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetEncoderCapacity)(
 *         vgpuInstance, encoderCapacity)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6538, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceGetEnco};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6538, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6538, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6537
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetEncoderCapacity == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetEncoderCapacity is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetEncoderCapacity)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6536
 *     global __nvmlVgpuInstanceGetEncoderCapacity
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetEncoderCapacity == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetEncoderCapacity is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6539
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetEncoderCapacity is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetEncoderCapacity)(             # <<<<<<<<<<<<<<
 *         vgpuInstance, encoderCapacity)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEncoderCapacity)(__pyx_v_vgpuInstance, __pyx_v_encoderCapacity);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6533
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetEncoderCapacity(nvmlVgpuInstance_t vgpuInstance, unsigned int* encoderCapacity) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetEncoderCapacity
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceGetEncoderCapacity", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6543
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceSetEncoderCapacity(nvmlVgpuInstance_t vgpuInstance, unsigned int encoderCapacity) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceSetEncoderCapacity
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceSetEncoderCapacity(nvmlVgpuInstance_t __pyx_v_vgpuInstance, unsigned int __pyx_v_encoderCapacity) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceSetEncoderCapacity", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6545
 * cdef nvmlReturn_t _nvmlVgpuInstanceSetEncoderCapacity(nvmlVgpuInstance_t vgpuInstance, unsigned int encoderCapacity) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceSetEncoderCapacity
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceSetEncoderCapacity == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6545, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6546
 *     global __nvmlVgpuInstanceSetEncoderCapacity
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceSetEncoderCapacity == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceSetEncoderCapacity is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceSetEncoderCapacity == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6547
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceSetEncoderCapacity == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceSetEncoderCapacity is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int) noexcept nogil>__nvmlVgpuInstanceSetEncoderCapacity)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6548
 *     if __nvmlVgpuInstanceSetEncoderCapacity == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceSetEncoderCapacity is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int) noexcept nogil>__nvmlVgpuInstanceSetEncoderCapacity)(
 *         vgpuInstance, encoderCapacity)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6548, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceSetEnco};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6548, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6548, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6547
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceSetEncoderCapacity == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceSetEncoderCapacity is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int) noexcept nogil>__nvmlVgpuInstanceSetEncoderCapacity)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6546
 *     global __nvmlVgpuInstanceSetEncoderCapacity
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceSetEncoderCapacity == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceSetEncoderCapacity is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6549
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceSetEncoderCapacity is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int) noexcept nogil>__nvmlVgpuInstanceSetEncoderCapacity)(             # <<<<<<<<<<<<<<
 *         vgpuInstance, encoderCapacity)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceSetEncoderCapacity)(__pyx_v_vgpuInstance, __pyx_v_encoderCapacity);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6543
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceSetEncoderCapacity(nvmlVgpuInstance_t vgpuInstance, unsigned int encoderCapacity) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceSetEncoderCapacity
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceSetEncoderCapacity", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6553
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetEncoderStats(nvmlVgpuInstance_t vgpuInstance, unsigned int* sessionCount, unsigned int* averageFps, unsigned int* averageLatency) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetEncoderStats
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetEncoderStats(nvmlVgpuInstance_t __pyx_v_vgpuInstance, unsigned int *__pyx_v_sessionCount, unsigned int *__pyx_v_averageFps, unsigned int *__pyx_v_averageLatency) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceGetEncoderStats", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6555
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetEncoderStats(nvmlVgpuInstance_t vgpuInstance, unsigned int* sessionCount, unsigned int* averageFps, unsigned int* averageLatency) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceGetEncoderStats
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceGetEncoderStats == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6555, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6556
 *     global __nvmlVgpuInstanceGetEncoderStats
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetEncoderStats == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetEncoderStats is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEncoderStats == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6557
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetEncoderStats == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetEncoderStats is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*, unsigned int*, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetEncoderStats)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6558
 *     if __nvmlVgpuInstanceGetEncoderStats == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetEncoderStats is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*, unsigned int*, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetEncoderStats)(
 *         vgpuInstance, sessionCount, averageFps, averageLatency)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6558, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceGetEnco_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6558, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6558, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6557
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetEncoderStats == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetEncoderStats is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*, unsigned int*, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetEncoderStats)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6556
 *     global __nvmlVgpuInstanceGetEncoderStats
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetEncoderStats == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetEncoderStats is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6559
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetEncoderStats is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*, unsigned int*, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetEncoderStats)(             # <<<<<<<<<<<<<<
 *         vgpuInstance, sessionCount, averageFps, averageLatency)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int *, unsigned int *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEncoderStats)(__pyx_v_vgpuInstance, __pyx_v_sessionCount, __pyx_v_averageFps, __pyx_v_averageLatency);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6553
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetEncoderStats(nvmlVgpuInstance_t vgpuInstance, unsigned int* sessionCount, unsigned int* averageFps, unsigned int* averageLatency) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetEncoderStats
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceGetEncoderStats", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6563
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetEncoderSessions(nvmlVgpuInstance_t vgpuInstance, unsigned int* sessionCount, nvmlEncoderSessionInfo_t* sessionInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetEncoderSessions
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetEncoderSessions(nvmlVgpuInstance_t __pyx_v_vgpuInstance, unsigned int *__pyx_v_sessionCount, nvmlEncoderSessionInfo_t *__pyx_v_sessionInfo) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceGetEncoderSessions", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6565
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetEncoderSessions(nvmlVgpuInstance_t vgpuInstance, unsigned int* sessionCount, nvmlEncoderSessionInfo_t* sessionInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceGetEncoderSessions
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceGetEncoderSessions == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6565, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6566
 *     global __nvmlVgpuInstanceGetEncoderSessions
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetEncoderSessions == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetEncoderSessions is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEncoderSessions == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6567
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetEncoderSessions == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetEncoderSessions is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*, nvmlEncoderSessionInfo_t*) noexcept nogil>__nvmlVgpuInstanceGetEncoderSessions)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6568
 *     if __nvmlVgpuInstanceGetEncoderSessions == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetEncoderSessions is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*, nvmlEncoderSessionInfo_t*) noexcept nogil>__nvmlVgpuInstanceGetEncoderSessions)(
 *         vgpuInstance, sessionCount, sessionInfo)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6568, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceGetEnco_3};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6568, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6568, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6567
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetEncoderSessions == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetEncoderSessions is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*, nvmlEncoderSessionInfo_t*) noexcept nogil>__nvmlVgpuInstanceGetEncoderSessions)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6566
 *     global __nvmlVgpuInstanceGetEncoderSessions
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetEncoderSessions == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetEncoderSessions is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6569
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetEncoderSessions is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*, nvmlEncoderSessionInfo_t*) noexcept nogil>__nvmlVgpuInstanceGetEncoderSessions)(             # <<<<<<<<<<<<<<
 *         vgpuInstance, sessionCount, sessionInfo)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int *, nvmlEncoderSessionInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEncoderSessions)(__pyx_v_vgpuInstance, __pyx_v_sessionCount, __pyx_v_sessionInfo);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6563
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetEncoderSessions(nvmlVgpuInstance_t vgpuInstance, unsigned int* sessionCount, nvmlEncoderSessionInfo_t* sessionInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetEncoderSessions
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceGetEncoderSessions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6573
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetFBCStats(nvmlVgpuInstance_t vgpuInstance, nvmlFBCStats_t* fbcStats) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetFBCStats
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetFBCStats(nvmlVgpuInstance_t __pyx_v_vgpuInstance, nvmlFBCStats_t *__pyx_v_fbcStats) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceGetFBCStats", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6575
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetFBCStats(nvmlVgpuInstance_t vgpuInstance, nvmlFBCStats_t* fbcStats) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceGetFBCStats
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceGetFBCStats == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6575, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6576
 *     global __nvmlVgpuInstanceGetFBCStats
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetFBCStats == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetFBCStats is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFBCStats == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6577
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetFBCStats == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetFBCStats is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlFBCStats_t*) noexcept nogil>__nvmlVgpuInstanceGetFBCStats)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6578
 *     if __nvmlVgpuInstanceGetFBCStats == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetFBCStats is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlFBCStats_t*) noexcept nogil>__nvmlVgpuInstanceGetFBCStats)(
 *         vgpuInstance, fbcStats)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6578, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceGetFBCS};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6578, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6578, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6577
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetFBCStats == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetFBCStats is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlFBCStats_t*) noexcept nogil>__nvmlVgpuInstanceGetFBCStats)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6576
 *     global __nvmlVgpuInstanceGetFBCStats
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetFBCStats == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetFBCStats is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6579
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetFBCStats is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlFBCStats_t*) noexcept nogil>__nvmlVgpuInstanceGetFBCStats)(             # <<<<<<<<<<<<<<
 *         vgpuInstance, fbcStats)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlFBCStats_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFBCStats)(__pyx_v_vgpuInstance, __pyx_v_fbcStats);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6573
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetFBCStats(nvmlVgpuInstance_t vgpuInstance, nvmlFBCStats_t* fbcStats) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetFBCStats
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceGetFBCStats", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6583
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetFBCSessions(nvmlVgpuInstance_t vgpuInstance, unsigned int* sessionCount, nvmlFBCSessionInfo_t* sessionInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetFBCSessions
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetFBCSessions(nvmlVgpuInstance_t __pyx_v_vgpuInstance, unsigned int *__pyx_v_sessionCount, nvmlFBCSessionInfo_t *__pyx_v_sessionInfo) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceGetFBCSessions", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6585
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetFBCSessions(nvmlVgpuInstance_t vgpuInstance, unsigned int* sessionCount, nvmlFBCSessionInfo_t* sessionInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceGetFBCSessions
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceGetFBCSessions == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6585, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6586
 *     global __nvmlVgpuInstanceGetFBCSessions
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetFBCSessions == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetFBCSessions is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFBCSessions == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6587
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetFBCSessions == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetFBCSessions is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*, nvmlFBCSessionInfo_t*) noexcept nogil>__nvmlVgpuInstanceGetFBCSessions)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6588
 *     if __nvmlVgpuInstanceGetFBCSessions == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetFBCSessions is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*, nvmlFBCSessionInfo_t*) noexcept nogil>__nvmlVgpuInstanceGetFBCSessions)(
 *         vgpuInstance, sessionCount, sessionInfo)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6588, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceGetFBCS_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6588, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6588, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6587
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetFBCSessions == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetFBCSessions is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*, nvmlFBCSessionInfo_t*) noexcept nogil>__nvmlVgpuInstanceGetFBCSessions)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6586
 *     global __nvmlVgpuInstanceGetFBCSessions
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetFBCSessions == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetFBCSessions is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6589
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetFBCSessions is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*, nvmlFBCSessionInfo_t*) noexcept nogil>__nvmlVgpuInstanceGetFBCSessions)(             # <<<<<<<<<<<<<<
 *         vgpuInstance, sessionCount, sessionInfo)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int *, nvmlFBCSessionInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFBCSessions)(__pyx_v_vgpuInstance, __pyx_v_sessionCount, __pyx_v_sessionInfo);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6583
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetFBCSessions(nvmlVgpuInstance_t vgpuInstance, unsigned int* sessionCount, nvmlFBCSessionInfo_t* sessionInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetFBCSessions
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceGetFBCSessions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6593
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetGpuInstanceId(nvmlVgpuInstance_t vgpuInstance, unsigned int* gpuInstanceId) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetGpuInstanceId
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetGpuInstanceId(nvmlVgpuInstance_t __pyx_v_vgpuInstance, unsigned int *__pyx_v_gpuInstanceId) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceGetGpuInstanceId", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6595
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetGpuInstanceId(nvmlVgpuInstance_t vgpuInstance, unsigned int* gpuInstanceId) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceGetGpuInstanceId
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceGetGpuInstanceId == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6595, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6596
 *     global __nvmlVgpuInstanceGetGpuInstanceId
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetGpuInstanceId == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetGpuInstanceId is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetGpuInstanceId == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6597
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetGpuInstanceId == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetGpuInstanceId is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetGpuInstanceId)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6598
 *     if __nvmlVgpuInstanceGetGpuInstanceId == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetGpuInstanceId is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetGpuInstanceId)(
 *         vgpuInstance, gpuInstanceId)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6598, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceGetGpuI};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6598, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6598, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6597
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetGpuInstanceId == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetGpuInstanceId is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetGpuInstanceId)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6596
 *     global __nvmlVgpuInstanceGetGpuInstanceId
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetGpuInstanceId == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetGpuInstanceId is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6599
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetGpuInstanceId is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetGpuInstanceId)(             # <<<<<<<<<<<<<<
 *         vgpuInstance, gpuInstanceId)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetGpuInstanceId)(__pyx_v_vgpuInstance, __pyx_v_gpuInstanceId);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6593
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetGpuInstanceId(nvmlVgpuInstance_t vgpuInstance, unsigned int* gpuInstanceId) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetGpuInstanceId
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceGetGpuInstanceId", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6603
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetGpuPciId(nvmlVgpuInstance_t vgpuInstance, char* vgpuPciId, unsigned int* length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetGpuPciId
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetGpuPciId(nvmlVgpuInstance_t __pyx_v_vgpuInstance, char *__pyx_v_vgpuPciId, unsigned int *__pyx_v_length) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceGetGpuPciId", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6605
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetGpuPciId(nvmlVgpuInstance_t vgpuInstance, char* vgpuPciId, unsigned int* length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceGetGpuPciId
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceGetGpuPciId == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6605, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6606
 *     global __nvmlVgpuInstanceGetGpuPciId
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetGpuPciId == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetGpuPciId is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetGpuPciId == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6607
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetGpuPciId == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetGpuPciId is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, char*, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetGpuPciId)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6608
 *     if __nvmlVgpuInstanceGetGpuPciId == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetGpuPciId is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, char*, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetGpuPciId)(
 *         vgpuInstance, vgpuPciId, length)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6608, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceGetGpuP};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6608, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6608, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6607
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetGpuPciId == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetGpuPciId is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, char*, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetGpuPciId)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6606
 *     global __nvmlVgpuInstanceGetGpuPciId
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetGpuPciId == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetGpuPciId is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6609
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetGpuPciId is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, char*, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetGpuPciId)(             # <<<<<<<<<<<<<<
 *         vgpuInstance, vgpuPciId, length)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t, char *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetGpuPciId)(__pyx_v_vgpuInstance, __pyx_v_vgpuPciId, __pyx_v_length);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6603
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetGpuPciId(nvmlVgpuInstance_t vgpuInstance, char* vgpuPciId, unsigned int* length) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetGpuPciId
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceGetGpuPciId", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6613
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetCapabilities(nvmlVgpuTypeId_t vgpuTypeId, nvmlVgpuCapability_t capability, unsigned int* capResult) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetCapabilities
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetCapabilities(nvmlVgpuTypeId_t __pyx_v_vgpuTypeId, nvmlVgpuCapability_t __pyx_v_capability, unsigned int *__pyx_v_capResult) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuTypeGetCapabilities", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6615
 * cdef nvmlReturn_t _nvmlVgpuTypeGetCapabilities(nvmlVgpuTypeId_t vgpuTypeId, nvmlVgpuCapability_t capability, unsigned int* capResult) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuTypeGetCapabilities
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuTypeGetCapabilities == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6615, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6616
 *     global __nvmlVgpuTypeGetCapabilities
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetCapabilities == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetCapabilities is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetCapabilities == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6617
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetCapabilities == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetCapabilities is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, nvmlVgpuCapability_t, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetCapabilities)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6618
 *     if __nvmlVgpuTypeGetCapabilities == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetCapabilities is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, nvmlVgpuCapability_t, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetCapabilities)(
 *         vgpuTypeId, capability, capResult)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6618, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuTypeGetCapabili};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6618, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6618, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6617
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetCapabilities == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetCapabilities is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, nvmlVgpuCapability_t, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetCapabilities)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6616
 *     global __nvmlVgpuTypeGetCapabilities
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetCapabilities == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetCapabilities is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6619
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetCapabilities is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeId_t, nvmlVgpuCapability_t, unsigned int*) noexcept nogil>__nvmlVgpuTypeGetCapabilities)(             # <<<<<<<<<<<<<<
 *         vgpuTypeId, capability, capResult)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuTypeId_t, nvmlVgpuCapability_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetCapabilities)(__pyx_v_vgpuTypeId, __pyx_v_capability, __pyx_v_capResult);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6613
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetCapabilities(nvmlVgpuTypeId_t vgpuTypeId, nvmlVgpuCapability_t capability, unsigned int* capResult) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetCapabilities
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuTypeGetCapabilities", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6623
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetMdevUUID(nvmlVgpuInstance_t vgpuInstance, char* mdevUuid, unsigned int size) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetMdevUUID
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetMdevUUID(nvmlVgpuInstance_t __pyx_v_vgpuInstance, char *__pyx_v_mdevUuid, unsigned int __pyx_v_size) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceGetMdevUUID", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6625
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetMdevUUID(nvmlVgpuInstance_t vgpuInstance, char* mdevUuid, unsigned int size) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceGetMdevUUID
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceGetMdevUUID == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6625, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6626
 *     global __nvmlVgpuInstanceGetMdevUUID
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetMdevUUID == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetMdevUUID is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetMdevUUID == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6627
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetMdevUUID == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetMdevUUID is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, char*, unsigned int) noexcept nogil>__nvmlVgpuInstanceGetMdevUUID)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6628
 *     if __nvmlVgpuInstanceGetMdevUUID == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetMdevUUID is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, char*, unsigned int) noexcept nogil>__nvmlVgpuInstanceGetMdevUUID)(
 *         vgpuInstance, mdevUuid, size)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6628, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceGetMdev};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6628, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6628, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6627
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetMdevUUID == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetMdevUUID is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, char*, unsigned int) noexcept nogil>__nvmlVgpuInstanceGetMdevUUID)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6626
 *     global __nvmlVgpuInstanceGetMdevUUID
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetMdevUUID == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetMdevUUID is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6629
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetMdevUUID is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, char*, unsigned int) noexcept nogil>__nvmlVgpuInstanceGetMdevUUID)(             # <<<<<<<<<<<<<<
 *         vgpuInstance, mdevUuid, size)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t, char *, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetMdevUUID)(__pyx_v_vgpuInstance, __pyx_v_mdevUuid, __pyx_v_size);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6623
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetMdevUUID(nvmlVgpuInstance_t vgpuInstance, char* mdevUuid, unsigned int size) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetMdevUUID
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceGetMdevUUID", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6633
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceGetCreatableVgpus(nvmlGpuInstance_t gpuInstance, nvmlVgpuTypeIdInfo_t* pVgpus) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceGetCreatableVgpus
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceGetCreatableVgpus(nvmlGpuInstance_t __pyx_v_gpuInstance, nvmlVgpuTypeIdInfo_t *__pyx_v_pVgpus) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGpuInstanceGetCreatableVgpus", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6635
 * cdef nvmlReturn_t _nvmlGpuInstanceGetCreatableVgpus(nvmlGpuInstance_t gpuInstance, nvmlVgpuTypeIdInfo_t* pVgpus) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGpuInstanceGetCreatableVgpus
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGpuInstanceGetCreatableVgpus == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6635, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6636
 *     global __nvmlGpuInstanceGetCreatableVgpus
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetCreatableVgpus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetCreatableVgpus is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetCreatableVgpus == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6637
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetCreatableVgpus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetCreatableVgpus is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuTypeIdInfo_t*) noexcept nogil>__nvmlGpuInstanceGetCreatableVgpus)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6638
 *     if __nvmlGpuInstanceGetCreatableVgpus == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetCreatableVgpus is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuTypeIdInfo_t*) noexcept nogil>__nvmlGpuInstanceGetCreatableVgpus)(
 *         gpuInstance, pVgpus)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6638, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGpuInstanceGetCreat};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6638, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6638, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6637
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetCreatableVgpus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetCreatableVgpus is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuTypeIdInfo_t*) noexcept nogil>__nvmlGpuInstanceGetCreatableVgpus)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6636
 *     global __nvmlGpuInstanceGetCreatableVgpus
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetCreatableVgpus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetCreatableVgpus is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6639
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetCreatableVgpus is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuTypeIdInfo_t*) noexcept nogil>__nvmlGpuInstanceGetCreatableVgpus)(             # <<<<<<<<<<<<<<
 *         gpuInstance, pVgpus)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuTypeIdInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetCreatableVgpus)(__pyx_v_gpuInstance, __pyx_v_pVgpus);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6633
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceGetCreatableVgpus(nvmlGpuInstance_t gpuInstance, nvmlVgpuTypeIdInfo_t* pVgpus) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceGetCreatableVgpus
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGpuInstanceGetCreatableVgpus", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6643
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetMaxInstancesPerGpuInstance(nvmlVgpuTypeMaxInstance_t* pMaxInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetMaxInstancesPerGpuInstance
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetMaxInstancesPerGpuInstance(nvmlVgpuTypeMaxInstance_t *__pyx_v_pMaxInstance) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuTypeGetMaxInstancesPerGpuInstance", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6645
 * cdef nvmlReturn_t _nvmlVgpuTypeGetMaxInstancesPerGpuInstance(nvmlVgpuTypeMaxInstance_t* pMaxInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuTypeGetMaxInstancesPerGpuInstance
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuTypeGetMaxInstancesPerGpuInstance == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6645, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6646
 *     global __nvmlVgpuTypeGetMaxInstancesPerGpuInstance
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetMaxInstancesPerGpuInstance == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetMaxInstancesPerGpuInstance is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetMaxInstancesPerGpuInstance == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6647
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetMaxInstancesPerGpuInstance == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetMaxInstancesPerGpuInstance is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeMaxInstance_t*) noexcept nogil>__nvmlVgpuTypeGetMaxInstancesPerGpuInstance)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6648
 *     if __nvmlVgpuTypeGetMaxInstancesPerGpuInstance == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetMaxInstancesPerGpuInstance is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeMaxInstance_t*) noexcept nogil>__nvmlVgpuTypeGetMaxInstancesPerGpuInstance)(
 *         pMaxInstance)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6648, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuTypeGetMaxInsta_3};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6648, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6648, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6647
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetMaxInstancesPerGpuInstance == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetMaxInstancesPerGpuInstance is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeMaxInstance_t*) noexcept nogil>__nvmlVgpuTypeGetMaxInstancesPerGpuInstance)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6646
 *     global __nvmlVgpuTypeGetMaxInstancesPerGpuInstance
 *     _check_or_init_nvml()
 *     if __nvmlVgpuTypeGetMaxInstancesPerGpuInstance == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetMaxInstancesPerGpuInstance is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6649
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuTypeGetMaxInstancesPerGpuInstance is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuTypeMaxInstance_t*) noexcept nogil>__nvmlVgpuTypeGetMaxInstancesPerGpuInstance)(             # <<<<<<<<<<<<<<
 *         pMaxInstance)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuTypeMaxInstance_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetMaxInstancesPerGpuInstance)(__pyx_v_pMaxInstance);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6643
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuTypeGetMaxInstancesPerGpuInstance(nvmlVgpuTypeMaxInstance_t* pMaxInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuTypeGetMaxInstancesPerGpuInstance
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuTypeGetMaxInstancesPerGpuInstance", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6653
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceGetActiveVgpus(nvmlGpuInstance_t gpuInstance, nvmlActiveVgpuInstanceInfo_t* pVgpuInstanceInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceGetActiveVgpus
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceGetActiveVgpus(nvmlGpuInstance_t __pyx_v_gpuInstance, nvmlActiveVgpuInstanceInfo_t *__pyx_v_pVgpuInstanceInfo) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGpuInstanceGetActiveVgpus", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6655
 * cdef nvmlReturn_t _nvmlGpuInstanceGetActiveVgpus(nvmlGpuInstance_t gpuInstance, nvmlActiveVgpuInstanceInfo_t* pVgpuInstanceInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGpuInstanceGetActiveVgpus
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGpuInstanceGetActiveVgpus == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6655, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6656
 *     global __nvmlGpuInstanceGetActiveVgpus
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetActiveVgpus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetActiveVgpus is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetActiveVgpus == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6657
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetActiveVgpus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetActiveVgpus is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlActiveVgpuInstanceInfo_t*) noexcept nogil>__nvmlGpuInstanceGetActiveVgpus)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6658
 *     if __nvmlGpuInstanceGetActiveVgpus == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetActiveVgpus is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlActiveVgpuInstanceInfo_t*) noexcept nogil>__nvmlGpuInstanceGetActiveVgpus)(
 *         gpuInstance, pVgpuInstanceInfo)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6658, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGpuInstanceGetActiv};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6658, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6658, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6657
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetActiveVgpus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetActiveVgpus is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlActiveVgpuInstanceInfo_t*) noexcept nogil>__nvmlGpuInstanceGetActiveVgpus)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6656
 *     global __nvmlGpuInstanceGetActiveVgpus
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetActiveVgpus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetActiveVgpus is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6659
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetActiveVgpus is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlActiveVgpuInstanceInfo_t*) noexcept nogil>__nvmlGpuInstanceGetActiveVgpus)(             # <<<<<<<<<<<<<<
 *         gpuInstance, pVgpuInstanceInfo)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlActiveVgpuInstanceInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetActiveVgpus)(__pyx_v_gpuInstance, __pyx_v_pVgpuInstanceInfo);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6653
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceGetActiveVgpus(nvmlGpuInstance_t gpuInstance, nvmlActiveVgpuInstanceInfo_t* pVgpuInstanceInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceGetActiveVgpus
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGpuInstanceGetActiveVgpus", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6663
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceSetVgpuSchedulerState(nvmlGpuInstance_t gpuInstance, nvmlVgpuSchedulerState_t* pScheduler) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceSetVgpuSchedulerState
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceSetVgpuSchedulerState(nvmlGpuInstance_t __pyx_v_gpuInstance, nvmlVgpuSchedulerState_t *__pyx_v_pScheduler) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGpuInstanceSetVgpuSchedulerState", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6665
 * cdef nvmlReturn_t _nvmlGpuInstanceSetVgpuSchedulerState(nvmlGpuInstance_t gpuInstance, nvmlVgpuSchedulerState_t* pScheduler) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGpuInstanceSetVgpuSchedulerState
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGpuInstanceSetVgpuSchedulerState == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6665, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6666
 *     global __nvmlGpuInstanceSetVgpuSchedulerState
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceSetVgpuSchedulerState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceSetVgpuSchedulerState is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceSetVgpuSchedulerState == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6667
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceSetVgpuSchedulerState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceSetVgpuSchedulerState is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuSchedulerState_t*) noexcept nogil>__nvmlGpuInstanceSetVgpuSchedulerState)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6668
 *     if __nvmlGpuInstanceSetVgpuSchedulerState == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceSetVgpuSchedulerState is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuSchedulerState_t*) noexcept nogil>__nvmlGpuInstanceSetVgpuSchedulerState)(
 *         gpuInstance, pScheduler)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6668, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGpuInstanceSetVgpuS};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6668, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6668, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6667
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceSetVgpuSchedulerState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceSetVgpuSchedulerState is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuSchedulerState_t*) noexcept nogil>__nvmlGpuInstanceSetVgpuSchedulerState)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6666
 *     global __nvmlGpuInstanceSetVgpuSchedulerState
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceSetVgpuSchedulerState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceSetVgpuSchedulerState is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6669
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceSetVgpuSchedulerState is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuSchedulerState_t*) noexcept nogil>__nvmlGpuInstanceSetVgpuSchedulerState)(             # <<<<<<<<<<<<<<
 *         gpuInstance, pScheduler)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuSchedulerState_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceSetVgpuSchedulerState)(__pyx_v_gpuInstance, __pyx_v_pScheduler);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6663
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceSetVgpuSchedulerState(nvmlGpuInstance_t gpuInstance, nvmlVgpuSchedulerState_t* pScheduler) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceSetVgpuSchedulerState
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGpuInstanceSetVgpuSchedulerState", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6673
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceGetVgpuSchedulerState(nvmlGpuInstance_t gpuInstance, nvmlVgpuSchedulerStateInfo_t* pSchedulerStateInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceGetVgpuSchedulerState
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceGetVgpuSchedulerState(nvmlGpuInstance_t __pyx_v_gpuInstance, nvmlVgpuSchedulerStateInfo_t *__pyx_v_pSchedulerStateInfo) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGpuInstanceGetVgpuSchedulerState", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6675
 * cdef nvmlReturn_t _nvmlGpuInstanceGetVgpuSchedulerState(nvmlGpuInstance_t gpuInstance, nvmlVgpuSchedulerStateInfo_t* pSchedulerStateInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGpuInstanceGetVgpuSchedulerState
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGpuInstanceGetVgpuSchedulerState == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6675, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6676
 *     global __nvmlGpuInstanceGetVgpuSchedulerState
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetVgpuSchedulerState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetVgpuSchedulerState is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuSchedulerState == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6677
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetVgpuSchedulerState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetVgpuSchedulerState is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuSchedulerStateInfo_t*) noexcept nogil>__nvmlGpuInstanceGetVgpuSchedulerState)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6678
 *     if __nvmlGpuInstanceGetVgpuSchedulerState == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetVgpuSchedulerState is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuSchedulerStateInfo_t*) noexcept nogil>__nvmlGpuInstanceGetVgpuSchedulerState)(
 *         gpuInstance, pSchedulerStateInfo)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6678, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGpuInstanceGetVgpuS};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6678, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6678, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6677
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetVgpuSchedulerState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetVgpuSchedulerState is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuSchedulerStateInfo_t*) noexcept nogil>__nvmlGpuInstanceGetVgpuSchedulerState)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6676
 *     global __nvmlGpuInstanceGetVgpuSchedulerState
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetVgpuSchedulerState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetVgpuSchedulerState is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6679
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetVgpuSchedulerState is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuSchedulerStateInfo_t*) noexcept nogil>__nvmlGpuInstanceGetVgpuSchedulerState)(             # <<<<<<<<<<<<<<
 *         gpuInstance, pSchedulerStateInfo)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuSchedulerStateInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuSchedulerState)(__pyx_v_gpuInstance, __pyx_v_pSchedulerStateInfo);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6673
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceGetVgpuSchedulerState(nvmlGpuInstance_t gpuInstance, nvmlVgpuSchedulerStateInfo_t* pSchedulerStateInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceGetVgpuSchedulerState
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGpuInstanceGetVgpuSchedulerState", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6683
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceGetVgpuSchedulerLog(nvmlGpuInstance_t gpuInstance, nvmlVgpuSchedulerLogInfo_t* pSchedulerLogInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceGetVgpuSchedulerLog
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceGetVgpuSchedulerLog(nvmlGpuInstance_t __pyx_v_gpuInstance, nvmlVgpuSchedulerLogInfo_t *__pyx_v_pSchedulerLogInfo) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGpuInstanceGetVgpuSchedulerLog", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6685
 * cdef nvmlReturn_t _nvmlGpuInstanceGetVgpuSchedulerLog(nvmlGpuInstance_t gpuInstance, nvmlVgpuSchedulerLogInfo_t* pSchedulerLogInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGpuInstanceGetVgpuSchedulerLog
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGpuInstanceGetVgpuSchedulerLog == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6685, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6686
 *     global __nvmlGpuInstanceGetVgpuSchedulerLog
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetVgpuSchedulerLog == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetVgpuSchedulerLog is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuSchedulerLog == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6687
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetVgpuSchedulerLog == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetVgpuSchedulerLog is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuSchedulerLogInfo_t*) noexcept nogil>__nvmlGpuInstanceGetVgpuSchedulerLog)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6688
 *     if __nvmlGpuInstanceGetVgpuSchedulerLog == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetVgpuSchedulerLog is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuSchedulerLogInfo_t*) noexcept nogil>__nvmlGpuInstanceGetVgpuSchedulerLog)(
 *         gpuInstance, pSchedulerLogInfo)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6688, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGpuInstanceGetVgpuS_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6688, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6688, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6687
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetVgpuSchedulerLog == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetVgpuSchedulerLog is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuSchedulerLogInfo_t*) noexcept nogil>__nvmlGpuInstanceGetVgpuSchedulerLog)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6686
 *     global __nvmlGpuInstanceGetVgpuSchedulerLog
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetVgpuSchedulerLog == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetVgpuSchedulerLog is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6689
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetVgpuSchedulerLog is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuSchedulerLogInfo_t*) noexcept nogil>__nvmlGpuInstanceGetVgpuSchedulerLog)(             # <<<<<<<<<<<<<<
 *         gpuInstance, pSchedulerLogInfo)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuSchedulerLogInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuSchedulerLog)(__pyx_v_gpuInstance, __pyx_v_pSchedulerLogInfo);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6683
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceGetVgpuSchedulerLog(nvmlGpuInstance_t gpuInstance, nvmlVgpuSchedulerLogInfo_t* pSchedulerLogInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceGetVgpuSchedulerLog
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGpuInstanceGetVgpuSchedulerLog", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6693
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceGetVgpuTypeCreatablePlacements(nvmlGpuInstance_t gpuInstance, nvmlVgpuCreatablePlacementInfo_t* pCreatablePlacementInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceGetVgpuTypeCreatablePlacements
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceGetVgpuTypeCreatablePlacements(nvmlGpuInstance_t __pyx_v_gpuInstance, nvmlVgpuCreatablePlacementInfo_t *__pyx_v_pCreatablePlacementInfo) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGpuInstanceGetVgpuTypeCreatablePlacements", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6695
 * cdef nvmlReturn_t _nvmlGpuInstanceGetVgpuTypeCreatablePlacements(nvmlGpuInstance_t gpuInstance, nvmlVgpuCreatablePlacementInfo_t* pCreatablePlacementInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGpuInstanceGetVgpuTypeCreatablePlacements
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGpuInstanceGetVgpuTypeCreatablePlacements == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6695, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6696
 *     global __nvmlGpuInstanceGetVgpuTypeCreatablePlacements
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetVgpuTypeCreatablePlacements == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetVgpuTypeCreatablePlacements is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuTypeCreatablePlacements == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6697
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetVgpuTypeCreatablePlacements == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetVgpuTypeCreatablePlacements is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuCreatablePlacementInfo_t*) noexcept nogil>__nvmlGpuInstanceGetVgpuTypeCreatablePlacements)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6698
 *     if __nvmlGpuInstanceGetVgpuTypeCreatablePlacements == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetVgpuTypeCreatablePlacements is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuCreatablePlacementInfo_t*) noexcept nogil>__nvmlGpuInstanceGetVgpuTypeCreatablePlacements)(
 *         gpuInstance, pCreatablePlacementInfo)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6698, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGpuInstanceGetVgpuT};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6698, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6698, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6697
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetVgpuTypeCreatablePlacements == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetVgpuTypeCreatablePlacements is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuCreatablePlacementInfo_t*) noexcept nogil>__nvmlGpuInstanceGetVgpuTypeCreatablePlacements)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6696
 *     global __nvmlGpuInstanceGetVgpuTypeCreatablePlacements
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetVgpuTypeCreatablePlacements == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetVgpuTypeCreatablePlacements is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6699
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetVgpuTypeCreatablePlacements is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuCreatablePlacementInfo_t*) noexcept nogil>__nvmlGpuInstanceGetVgpuTypeCreatablePlacements)(             # <<<<<<<<<<<<<<
 *         gpuInstance, pCreatablePlacementInfo)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuCreatablePlacementInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuTypeCreatablePlacements)(__pyx_v_gpuInstance, __pyx_v_pCreatablePlacementInfo);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6693
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceGetVgpuTypeCreatablePlacements(nvmlGpuInstance_t gpuInstance, nvmlVgpuCreatablePlacementInfo_t* pCreatablePlacementInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceGetVgpuTypeCreatablePlacements
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGpuInstanceGetVgpuTypeCreatablePlacements", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6703
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceGetVgpuHeterogeneousMode(nvmlGpuInstance_t gpuInstance, nvmlVgpuHeterogeneousMode_t* pHeterogeneousMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceGetVgpuHeterogeneousMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceGetVgpuHeterogeneousMode(nvmlGpuInstance_t __pyx_v_gpuInstance, nvmlVgpuHeterogeneousMode_t *__pyx_v_pHeterogeneousMode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGpuInstanceGetVgpuHeterogeneousMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6705
 * cdef nvmlReturn_t _nvmlGpuInstanceGetVgpuHeterogeneousMode(nvmlGpuInstance_t gpuInstance, nvmlVgpuHeterogeneousMode_t* pHeterogeneousMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGpuInstanceGetVgpuHeterogeneousMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGpuInstanceGetVgpuHeterogeneousMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6705, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6706
 *     global __nvmlGpuInstanceGetVgpuHeterogeneousMode
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetVgpuHeterogeneousMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetVgpuHeterogeneousMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuHeterogeneousMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6707
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetVgpuHeterogeneousMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetVgpuHeterogeneousMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuHeterogeneousMode_t*) noexcept nogil>__nvmlGpuInstanceGetVgpuHeterogeneousMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6708
 *     if __nvmlGpuInstanceGetVgpuHeterogeneousMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetVgpuHeterogeneousMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuHeterogeneousMode_t*) noexcept nogil>__nvmlGpuInstanceGetVgpuHeterogeneousMode)(
 *         gpuInstance, pHeterogeneousMode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6708, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGpuInstanceGetVgpuH};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6708, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6708, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6707
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetVgpuHeterogeneousMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetVgpuHeterogeneousMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuHeterogeneousMode_t*) noexcept nogil>__nvmlGpuInstanceGetVgpuHeterogeneousMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6706
 *     global __nvmlGpuInstanceGetVgpuHeterogeneousMode
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetVgpuHeterogeneousMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetVgpuHeterogeneousMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6709
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetVgpuHeterogeneousMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuHeterogeneousMode_t*) noexcept nogil>__nvmlGpuInstanceGetVgpuHeterogeneousMode)(             # <<<<<<<<<<<<<<
 *         gpuInstance, pHeterogeneousMode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuHeterogeneousMode_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuHeterogeneousMode)(__pyx_v_gpuInstance, __pyx_v_pHeterogeneousMode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6703
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceGetVgpuHeterogeneousMode(nvmlGpuInstance_t gpuInstance, nvmlVgpuHeterogeneousMode_t* pHeterogeneousMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceGetVgpuHeterogeneousMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGpuInstanceGetVgpuHeterogeneousMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6713
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceSetVgpuHeterogeneousMode(nvmlGpuInstance_t gpuInstance, const nvmlVgpuHeterogeneousMode_t* pHeterogeneousMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceSetVgpuHeterogeneousMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceSetVgpuHeterogeneousMode(nvmlGpuInstance_t __pyx_v_gpuInstance, nvmlVgpuHeterogeneousMode_t const *__pyx_v_pHeterogeneousMode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGpuInstanceSetVgpuHeterogeneousMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6715
 * cdef nvmlReturn_t _nvmlGpuInstanceSetVgpuHeterogeneousMode(nvmlGpuInstance_t gpuInstance, const nvmlVgpuHeterogeneousMode_t* pHeterogeneousMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGpuInstanceSetVgpuHeterogeneousMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGpuInstanceSetVgpuHeterogeneousMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6715, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6716
 *     global __nvmlGpuInstanceSetVgpuHeterogeneousMode
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceSetVgpuHeterogeneousMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceSetVgpuHeterogeneousMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceSetVgpuHeterogeneousMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6717
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceSetVgpuHeterogeneousMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceSetVgpuHeterogeneousMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, const nvmlVgpuHeterogeneousMode_t*) noexcept nogil>__nvmlGpuInstanceSetVgpuHeterogeneousMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6718
 *     if __nvmlGpuInstanceSetVgpuHeterogeneousMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceSetVgpuHeterogeneousMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, const nvmlVgpuHeterogeneousMode_t*) noexcept nogil>__nvmlGpuInstanceSetVgpuHeterogeneousMode)(
 *         gpuInstance, pHeterogeneousMode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6718, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGpuInstanceSetVgpuH};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6718, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6718, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6717
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceSetVgpuHeterogeneousMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceSetVgpuHeterogeneousMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, const nvmlVgpuHeterogeneousMode_t*) noexcept nogil>__nvmlGpuInstanceSetVgpuHeterogeneousMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6716
 *     global __nvmlGpuInstanceSetVgpuHeterogeneousMode
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceSetVgpuHeterogeneousMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceSetVgpuHeterogeneousMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6719
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceSetVgpuHeterogeneousMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, const nvmlVgpuHeterogeneousMode_t*) noexcept nogil>__nvmlGpuInstanceSetVgpuHeterogeneousMode)(             # <<<<<<<<<<<<<<
 *         gpuInstance, pHeterogeneousMode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlVgpuHeterogeneousMode_t const *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceSetVgpuHeterogeneousMode)(__pyx_v_gpuInstance, __pyx_v_pHeterogeneousMode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6713
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceSetVgpuHeterogeneousMode(nvmlGpuInstance_t gpuInstance, const nvmlVgpuHeterogeneousMode_t* pHeterogeneousMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceSetVgpuHeterogeneousMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGpuInstanceSetVgpuHeterogeneousMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6723
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetMetadata(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuMetadata_t* vgpuMetadata, unsigned int* bufferSize) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetMetadata
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetMetadata(nvmlVgpuInstance_t __pyx_v_vgpuInstance, nvmlVgpuMetadata_t *__pyx_v_vgpuMetadata, unsigned int *__pyx_v_bufferSize) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceGetMetadata", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6725
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetMetadata(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuMetadata_t* vgpuMetadata, unsigned int* bufferSize) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceGetMetadata
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceGetMetadata == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6725, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6726
 *     global __nvmlVgpuInstanceGetMetadata
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetMetadata == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetMetadata is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetMetadata == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6727
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetMetadata == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetMetadata is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuMetadata_t*, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetMetadata)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6728
 *     if __nvmlVgpuInstanceGetMetadata == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetMetadata is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuMetadata_t*, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetMetadata)(
 *         vgpuInstance, vgpuMetadata, bufferSize)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6728, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceGetMeta};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6728, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6728, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6727
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetMetadata == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetMetadata is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuMetadata_t*, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetMetadata)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6726
 *     global __nvmlVgpuInstanceGetMetadata
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetMetadata == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetMetadata is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6729
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetMetadata is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuMetadata_t*, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetMetadata)(             # <<<<<<<<<<<<<<
 *         vgpuInstance, vgpuMetadata, bufferSize)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuMetadata_t *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetMetadata)(__pyx_v_vgpuInstance, __pyx_v_vgpuMetadata, __pyx_v_bufferSize);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6723
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetMetadata(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuMetadata_t* vgpuMetadata, unsigned int* bufferSize) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetMetadata
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceGetMetadata", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6733
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuMetadata(nvmlDevice_t device, nvmlVgpuPgpuMetadata_t* pgpuMetadata, unsigned int* bufferSize) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVgpuMetadata
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVgpuMetadata(nvmlDevice_t __pyx_v_device, nvmlVgpuPgpuMetadata_t *__pyx_v_pgpuMetadata, unsigned int *__pyx_v_bufferSize) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetVgpuMetadata", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6735
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuMetadata(nvmlDevice_t device, nvmlVgpuPgpuMetadata_t* pgpuMetadata, unsigned int* bufferSize) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetVgpuMetadata
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetVgpuMetadata == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6735, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6736
 *     global __nvmlDeviceGetVgpuMetadata
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuMetadata == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuMetadata is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuMetadata == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6737
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuMetadata == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuMetadata is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuPgpuMetadata_t*, unsigned int*) noexcept nogil>__nvmlDeviceGetVgpuMetadata)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6738
 *     if __nvmlDeviceGetVgpuMetadata == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuMetadata is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuPgpuMetadata_t*, unsigned int*) noexcept nogil>__nvmlDeviceGetVgpuMetadata)(
 *         device, pgpuMetadata, bufferSize)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6738, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetVgpuMetada};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6738, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6738, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6737
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuMetadata == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuMetadata is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuPgpuMetadata_t*, unsigned int*) noexcept nogil>__nvmlDeviceGetVgpuMetadata)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6736
 *     global __nvmlDeviceGetVgpuMetadata
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuMetadata == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuMetadata is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6739
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuMetadata is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuPgpuMetadata_t*, unsigned int*) noexcept nogil>__nvmlDeviceGetVgpuMetadata)(             # <<<<<<<<<<<<<<
 *         device, pgpuMetadata, bufferSize)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuPgpuMetadata_t *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuMetadata)(__pyx_v_device, __pyx_v_pgpuMetadata, __pyx_v_bufferSize);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6733
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuMetadata(nvmlDevice_t device, nvmlVgpuPgpuMetadata_t* pgpuMetadata, unsigned int* bufferSize) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVgpuMetadata
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetVgpuMetadata", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6743
 * 
 * 
 * cdef nvmlReturn_t _nvmlGetVgpuCompatibility(nvmlVgpuMetadata_t* vgpuMetadata, nvmlVgpuPgpuMetadata_t* pgpuMetadata, nvmlVgpuPgpuCompatibility_t* compatibilityInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGetVgpuCompatibility
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGetVgpuCompatibility(nvmlVgpuMetadata_t *__pyx_v_vgpuMetadata, nvmlVgpuPgpuMetadata_t *__pyx_v_pgpuMetadata, nvmlVgpuPgpuCompatibility_t *__pyx_v_compatibilityInfo) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGetVgpuCompatibility", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6745
 * cdef nvmlReturn_t _nvmlGetVgpuCompatibility(nvmlVgpuMetadata_t* vgpuMetadata, nvmlVgpuPgpuMetadata_t* pgpuMetadata, nvmlVgpuPgpuCompatibility_t* compatibilityInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGetVgpuCompatibility
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGetVgpuCompatibility == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6745, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6746
 *     global __nvmlGetVgpuCompatibility
 *     _check_or_init_nvml()
 *     if __nvmlGetVgpuCompatibility == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGetVgpuCompatibility is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetVgpuCompatibility == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6747
 *     _check_or_init_nvml()
 *     if __nvmlGetVgpuCompatibility == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGetVgpuCompatibility is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuMetadata_t*, nvmlVgpuPgpuMetadata_t*, nvmlVgpuPgpuCompatibility_t*) noexcept nogil>__nvmlGetVgpuCompatibility)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6748
 *     if __nvmlGetVgpuCompatibility == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGetVgpuCompatibility is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuMetadata_t*, nvmlVgpuPgpuMetadata_t*, nvmlVgpuPgpuCompatibility_t*) noexcept nogil>__nvmlGetVgpuCompatibility)(
 *         vgpuMetadata, pgpuMetadata, compatibilityInfo)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6748, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGetVgpuCompatibilit};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6748, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6748, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6747
 *     _check_or_init_nvml()
 *     if __nvmlGetVgpuCompatibility == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGetVgpuCompatibility is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuMetadata_t*, nvmlVgpuPgpuMetadata_t*, nvmlVgpuPgpuCompatibility_t*) noexcept nogil>__nvmlGetVgpuCompatibility)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6746
 *     global __nvmlGetVgpuCompatibility
 *     _check_or_init_nvml()
 *     if __nvmlGetVgpuCompatibility == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGetVgpuCompatibility is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6749
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGetVgpuCompatibility is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuMetadata_t*, nvmlVgpuPgpuMetadata_t*, nvmlVgpuPgpuCompatibility_t*) noexcept nogil>__nvmlGetVgpuCompatibility)(             # <<<<<<<<<<<<<<
 *         vgpuMetadata, pgpuMetadata, compatibilityInfo)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuMetadata_t *, nvmlVgpuPgpuMetadata_t *, nvmlVgpuPgpuCompatibility_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetVgpuCompatibility)(__pyx_v_vgpuMetadata, __pyx_v_pgpuMetadata, __pyx_v_compatibilityInfo);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6743
 * 
 * 
 * cdef nvmlReturn_t _nvmlGetVgpuCompatibility(nvmlVgpuMetadata_t* vgpuMetadata, nvmlVgpuPgpuMetadata_t* pgpuMetadata, nvmlVgpuPgpuCompatibility_t* compatibilityInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGetVgpuCompatibility
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGetVgpuCompatibility", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6753
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPgpuMetadataString(nvmlDevice_t device, char* pgpuMetadata, unsigned int* bufferSize) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPgpuMetadataString
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPgpuMetadataString(nvmlDevice_t __pyx_v_device, char *__pyx_v_pgpuMetadata, unsigned int *__pyx_v_bufferSize) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetPgpuMetadataString", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6755
 * cdef nvmlReturn_t _nvmlDeviceGetPgpuMetadataString(nvmlDevice_t device, char* pgpuMetadata, unsigned int* bufferSize) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetPgpuMetadataString
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetPgpuMetadataString == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6755, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6756
 *     global __nvmlDeviceGetPgpuMetadataString
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPgpuMetadataString == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPgpuMetadataString is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPgpuMetadataString == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6757
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPgpuMetadataString == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPgpuMetadataString is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int*) noexcept nogil>__nvmlDeviceGetPgpuMetadataString)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6758
 *     if __nvmlDeviceGetPgpuMetadataString == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPgpuMetadataString is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int*) noexcept nogil>__nvmlDeviceGetPgpuMetadataString)(
 *         device, pgpuMetadata, bufferSize)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6758, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetPgpuMetada};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6758, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6758, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6757
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPgpuMetadataString == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPgpuMetadataString is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int*) noexcept nogil>__nvmlDeviceGetPgpuMetadataString)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6756
 *     global __nvmlDeviceGetPgpuMetadataString
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPgpuMetadataString == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPgpuMetadataString is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6759
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPgpuMetadataString is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, char*, unsigned int*) noexcept nogil>__nvmlDeviceGetPgpuMetadataString)(             # <<<<<<<<<<<<<<
 *         device, pgpuMetadata, bufferSize)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, char *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPgpuMetadataString)(__pyx_v_device, __pyx_v_pgpuMetadata, __pyx_v_bufferSize);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6753
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPgpuMetadataString(nvmlDevice_t device, char* pgpuMetadata, unsigned int* bufferSize) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPgpuMetadataString
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetPgpuMetadataString", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6763
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuSchedulerLog(nvmlDevice_t device, nvmlVgpuSchedulerLog_t* pSchedulerLog) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVgpuSchedulerLog
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVgpuSchedulerLog(nvmlDevice_t __pyx_v_device, nvmlVgpuSchedulerLog_t *__pyx_v_pSchedulerLog) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetVgpuSchedulerLog", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6765
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuSchedulerLog(nvmlDevice_t device, nvmlVgpuSchedulerLog_t* pSchedulerLog) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetVgpuSchedulerLog
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetVgpuSchedulerLog == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6765, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6766
 *     global __nvmlDeviceGetVgpuSchedulerLog
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuSchedulerLog == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuSchedulerLog is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuSchedulerLog == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6767
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuSchedulerLog == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuSchedulerLog is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuSchedulerLog_t*) noexcept nogil>__nvmlDeviceGetVgpuSchedulerLog)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6768
 *     if __nvmlDeviceGetVgpuSchedulerLog == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuSchedulerLog is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuSchedulerLog_t*) noexcept nogil>__nvmlDeviceGetVgpuSchedulerLog)(
 *         device, pSchedulerLog)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6768, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetVgpuSchedu};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6768, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6768, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6767
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuSchedulerLog == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuSchedulerLog is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuSchedulerLog_t*) noexcept nogil>__nvmlDeviceGetVgpuSchedulerLog)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6766
 *     global __nvmlDeviceGetVgpuSchedulerLog
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuSchedulerLog == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuSchedulerLog is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6769
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuSchedulerLog is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuSchedulerLog_t*) noexcept nogil>__nvmlDeviceGetVgpuSchedulerLog)(             # <<<<<<<<<<<<<<
 *         device, pSchedulerLog)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuSchedulerLog_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuSchedulerLog)(__pyx_v_device, __pyx_v_pSchedulerLog);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6763
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuSchedulerLog(nvmlDevice_t device, nvmlVgpuSchedulerLog_t* pSchedulerLog) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVgpuSchedulerLog
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetVgpuSchedulerLog", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6773
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuSchedulerState(nvmlDevice_t device, nvmlVgpuSchedulerGetState_t* pSchedulerState) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVgpuSchedulerState
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVgpuSchedulerState(nvmlDevice_t __pyx_v_device, nvmlVgpuSchedulerGetState_t *__pyx_v_pSchedulerState) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetVgpuSchedulerState", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6775
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuSchedulerState(nvmlDevice_t device, nvmlVgpuSchedulerGetState_t* pSchedulerState) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetVgpuSchedulerState
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetVgpuSchedulerState == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6775, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6776
 *     global __nvmlDeviceGetVgpuSchedulerState
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuSchedulerState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuSchedulerState is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuSchedulerState == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6777
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuSchedulerState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuSchedulerState is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuSchedulerGetState_t*) noexcept nogil>__nvmlDeviceGetVgpuSchedulerState)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6778
 *     if __nvmlDeviceGetVgpuSchedulerState == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuSchedulerState is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuSchedulerGetState_t*) noexcept nogil>__nvmlDeviceGetVgpuSchedulerState)(
 *         device, pSchedulerState)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6778, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetVgpuSchedu_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6778, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6778, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6777
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuSchedulerState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuSchedulerState is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuSchedulerGetState_t*) noexcept nogil>__nvmlDeviceGetVgpuSchedulerState)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6776
 *     global __nvmlDeviceGetVgpuSchedulerState
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuSchedulerState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuSchedulerState is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6779
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuSchedulerState is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuSchedulerGetState_t*) noexcept nogil>__nvmlDeviceGetVgpuSchedulerState)(             # <<<<<<<<<<<<<<
 *         device, pSchedulerState)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuSchedulerGetState_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuSchedulerState)(__pyx_v_device, __pyx_v_pSchedulerState);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6773
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuSchedulerState(nvmlDevice_t device, nvmlVgpuSchedulerGetState_t* pSchedulerState) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVgpuSchedulerState
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetVgpuSchedulerState", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6783
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuSchedulerCapabilities(nvmlDevice_t device, nvmlVgpuSchedulerCapabilities_t* pCapabilities) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVgpuSchedulerCapabilities
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVgpuSchedulerCapabilities(nvmlDevice_t __pyx_v_device, nvmlVgpuSchedulerCapabilities_t *__pyx_v_pCapabilities) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetVgpuSchedulerCapabilities", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6785
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuSchedulerCapabilities(nvmlDevice_t device, nvmlVgpuSchedulerCapabilities_t* pCapabilities) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetVgpuSchedulerCapabilities
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetVgpuSchedulerCapabilities == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6785, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6786
 *     global __nvmlDeviceGetVgpuSchedulerCapabilities
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuSchedulerCapabilities == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuSchedulerCapabilities is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuSchedulerCapabilities == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6787
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuSchedulerCapabilities == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuSchedulerCapabilities is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuSchedulerCapabilities_t*) noexcept nogil>__nvmlDeviceGetVgpuSchedulerCapabilities)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6788
 *     if __nvmlDeviceGetVgpuSchedulerCapabilities == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuSchedulerCapabilities is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuSchedulerCapabilities_t*) noexcept nogil>__nvmlDeviceGetVgpuSchedulerCapabilities)(
 *         device, pCapabilities)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6788, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetVgpuSchedu_3};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6788, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6788, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6787
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuSchedulerCapabilities == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuSchedulerCapabilities is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuSchedulerCapabilities_t*) noexcept nogil>__nvmlDeviceGetVgpuSchedulerCapabilities)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6786
 *     global __nvmlDeviceGetVgpuSchedulerCapabilities
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuSchedulerCapabilities == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuSchedulerCapabilities is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6789
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuSchedulerCapabilities is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuSchedulerCapabilities_t*) noexcept nogil>__nvmlDeviceGetVgpuSchedulerCapabilities)(             # <<<<<<<<<<<<<<
 *         device, pCapabilities)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuSchedulerCapabilities_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuSchedulerCapabilities)(__pyx_v_device, __pyx_v_pCapabilities);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6783
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuSchedulerCapabilities(nvmlDevice_t device, nvmlVgpuSchedulerCapabilities_t* pCapabilities) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVgpuSchedulerCapabilities
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetVgpuSchedulerCapabilities", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6793
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetVgpuSchedulerState(nvmlDevice_t device, nvmlVgpuSchedulerSetState_t* pSchedulerState) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetVgpuSchedulerState
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetVgpuSchedulerState(nvmlDevice_t __pyx_v_device, nvmlVgpuSchedulerSetState_t *__pyx_v_pSchedulerState) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetVgpuSchedulerState", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6795
 * cdef nvmlReturn_t _nvmlDeviceSetVgpuSchedulerState(nvmlDevice_t device, nvmlVgpuSchedulerSetState_t* pSchedulerState) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetVgpuSchedulerState
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetVgpuSchedulerState == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6795, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6796
 *     global __nvmlDeviceSetVgpuSchedulerState
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetVgpuSchedulerState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetVgpuSchedulerState is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVgpuSchedulerState == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6797
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetVgpuSchedulerState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetVgpuSchedulerState is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuSchedulerSetState_t*) noexcept nogil>__nvmlDeviceSetVgpuSchedulerState)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6798
 *     if __nvmlDeviceSetVgpuSchedulerState == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetVgpuSchedulerState is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuSchedulerSetState_t*) noexcept nogil>__nvmlDeviceSetVgpuSchedulerState)(
 *         device, pSchedulerState)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6798, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetVgpuSchedu};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6798, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6798, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6797
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetVgpuSchedulerState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetVgpuSchedulerState is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuSchedulerSetState_t*) noexcept nogil>__nvmlDeviceSetVgpuSchedulerState)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6796
 *     global __nvmlDeviceSetVgpuSchedulerState
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetVgpuSchedulerState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetVgpuSchedulerState is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6799
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetVgpuSchedulerState is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuSchedulerSetState_t*) noexcept nogil>__nvmlDeviceSetVgpuSchedulerState)(             # <<<<<<<<<<<<<<
 *         device, pSchedulerState)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuSchedulerSetState_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVgpuSchedulerState)(__pyx_v_device, __pyx_v_pSchedulerState);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6793
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetVgpuSchedulerState(nvmlDevice_t device, nvmlVgpuSchedulerSetState_t* pSchedulerState) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetVgpuSchedulerState
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetVgpuSchedulerState", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6803
 * 
 * 
 * cdef nvmlReturn_t _nvmlGetVgpuVersion(nvmlVgpuVersion_t* supported, nvmlVgpuVersion_t* current) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGetVgpuVersion
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGetVgpuVersion(nvmlVgpuVersion_t *__pyx_v_supported, nvmlVgpuVersion_t *__pyx_v_current) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGetVgpuVersion", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6805
 * cdef nvmlReturn_t _nvmlGetVgpuVersion(nvmlVgpuVersion_t* supported, nvmlVgpuVersion_t* current) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGetVgpuVersion
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGetVgpuVersion == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6805, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6806
 *     global __nvmlGetVgpuVersion
 *     _check_or_init_nvml()
 *     if __nvmlGetVgpuVersion == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGetVgpuVersion is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetVgpuVersion == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6807
 *     _check_or_init_nvml()
 *     if __nvmlGetVgpuVersion == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGetVgpuVersion is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuVersion_t*, nvmlVgpuVersion_t*) noexcept nogil>__nvmlGetVgpuVersion)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6808
 *     if __nvmlGetVgpuVersion == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGetVgpuVersion is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuVersion_t*, nvmlVgpuVersion_t*) noexcept nogil>__nvmlGetVgpuVersion)(
 *         supported, current)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6808, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGetVgpuVersion_is_n};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6808, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6808, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6807
 *     _check_or_init_nvml()
 *     if __nvmlGetVgpuVersion == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGetVgpuVersion is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuVersion_t*, nvmlVgpuVersion_t*) noexcept nogil>__nvmlGetVgpuVersion)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6806
 *     global __nvmlGetVgpuVersion
 *     _check_or_init_nvml()
 *     if __nvmlGetVgpuVersion == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGetVgpuVersion is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6809
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGetVgpuVersion is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuVersion_t*, nvmlVgpuVersion_t*) noexcept nogil>__nvmlGetVgpuVersion)(             # <<<<<<<<<<<<<<
 *         supported, current)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuVersion_t *, nvmlVgpuVersion_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetVgpuVersion)(__pyx_v_supported, __pyx_v_current);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6803
 * 
 * 
 * cdef nvmlReturn_t _nvmlGetVgpuVersion(nvmlVgpuVersion_t* supported, nvmlVgpuVersion_t* current) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGetVgpuVersion
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGetVgpuVersion", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6813
 * 
 * 
 * cdef nvmlReturn_t _nvmlSetVgpuVersion(nvmlVgpuVersion_t* vgpuVersion) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSetVgpuVersion
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSetVgpuVersion(nvmlVgpuVersion_t *__pyx_v_vgpuVersion) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlSetVgpuVersion", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6815
 * cdef nvmlReturn_t _nvmlSetVgpuVersion(nvmlVgpuVersion_t* vgpuVersion) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlSetVgpuVersion
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlSetVgpuVersion == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6815, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6816
 *     global __nvmlSetVgpuVersion
 *     _check_or_init_nvml()
 *     if __nvmlSetVgpuVersion == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSetVgpuVersion is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSetVgpuVersion == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6817
 *     _check_or_init_nvml()
 *     if __nvmlSetVgpuVersion == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSetVgpuVersion is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuVersion_t*) noexcept nogil>__nvmlSetVgpuVersion)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6818
 *     if __nvmlSetVgpuVersion == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSetVgpuVersion is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuVersion_t*) noexcept nogil>__nvmlSetVgpuVersion)(
 *         vgpuVersion)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6818, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlSetVgpuVersion_is_n};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6818, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6818, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6817
 *     _check_or_init_nvml()
 *     if __nvmlSetVgpuVersion == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlSetVgpuVersion is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuVersion_t*) noexcept nogil>__nvmlSetVgpuVersion)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6816
 *     global __nvmlSetVgpuVersion
 *     _check_or_init_nvml()
 *     if __nvmlSetVgpuVersion == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSetVgpuVersion is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6819
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlSetVgpuVersion is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuVersion_t*) noexcept nogil>__nvmlSetVgpuVersion)(             # <<<<<<<<<<<<<<
 *         vgpuVersion)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuVersion_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSetVgpuVersion)(__pyx_v_vgpuVersion);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6813
 * 
 * 
 * cdef nvmlReturn_t _nvmlSetVgpuVersion(nvmlVgpuVersion_t* vgpuVersion) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlSetVgpuVersion
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlSetVgpuVersion", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6823
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuUtilization(nvmlDevice_t device, unsigned long long lastSeenTimeStamp, nvmlValueType_t* sampleValType, unsigned int* vgpuInstanceSamplesCount, nvmlVgpuInstanceUtilizationSample_t* utilizationSamples) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVgpuUtilization
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVgpuUtilization(nvmlDevice_t __pyx_v_device, unsigned PY_LONG_LONG __pyx_v_lastSeenTimeStamp, nvmlValueType_t *__pyx_v_sampleValType, unsigned int *__pyx_v_vgpuInstanceSamplesCount, nvmlVgpuInstanceUtilizationSample_t *__pyx_v_utilizationSamples) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetVgpuUtilization", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6825
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuUtilization(nvmlDevice_t device, unsigned long long lastSeenTimeStamp, nvmlValueType_t* sampleValType, unsigned int* vgpuInstanceSamplesCount, nvmlVgpuInstanceUtilizationSample_t* utilizationSamples) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetVgpuUtilization
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetVgpuUtilization == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6825, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6826
 *     global __nvmlDeviceGetVgpuUtilization
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuUtilization == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuUtilization is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuUtilization == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6827
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuUtilization == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuUtilization is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long, nvmlValueType_t*, unsigned int*, nvmlVgpuInstanceUtilizationSample_t*) noexcept nogil>__nvmlDeviceGetVgpuUtilization)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6828
 *     if __nvmlDeviceGetVgpuUtilization == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuUtilization is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long, nvmlValueType_t*, unsigned int*, nvmlVgpuInstanceUtilizationSample_t*) noexcept nogil>__nvmlDeviceGetVgpuUtilization)(
 *         device, lastSeenTimeStamp, sampleValType, vgpuInstanceSamplesCount, utilizationSamples)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6828, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetVgpuUtiliz};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6828, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6828, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6827
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuUtilization == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuUtilization is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long, nvmlValueType_t*, unsigned int*, nvmlVgpuInstanceUtilizationSample_t*) noexcept nogil>__nvmlDeviceGetVgpuUtilization)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6826
 *     global __nvmlDeviceGetVgpuUtilization
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuUtilization == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuUtilization is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6829
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuUtilization is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long, nvmlValueType_t*, unsigned int*, nvmlVgpuInstanceUtilizationSample_t*) noexcept nogil>__nvmlDeviceGetVgpuUtilization)(             # <<<<<<<<<<<<<<
 *         device, lastSeenTimeStamp, sampleValType, vgpuInstanceSamplesCount, utilizationSamples)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned PY_LONG_LONG, nvmlValueType_t *, unsigned int *, nvmlVgpuInstanceUtilizationSample_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuUtilization)(__pyx_v_device, __pyx_v_lastSeenTimeStamp, __pyx_v_sampleValType, __pyx_v_vgpuInstanceSamplesCount, __pyx_v_utilizationSamples);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6823
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuUtilization(nvmlDevice_t device, unsigned long long lastSeenTimeStamp, nvmlValueType_t* sampleValType, unsigned int* vgpuInstanceSamplesCount, nvmlVgpuInstanceUtilizationSample_t* utilizationSamples) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVgpuUtilization
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetVgpuUtilization", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6833
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuInstancesUtilizationInfo(nvmlDevice_t device, nvmlVgpuInstancesUtilizationInfo_t* vgpuUtilInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVgpuInstancesUtilizationInfo
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVgpuInstancesUtilizationInfo(nvmlDevice_t __pyx_v_device, nvmlVgpuInstancesUtilizationInfo_t *__pyx_v_vgpuUtilInfo) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetVgpuInstancesUtilizationInfo", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6835
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuInstancesUtilizationInfo(nvmlDevice_t device, nvmlVgpuInstancesUtilizationInfo_t* vgpuUtilInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetVgpuInstancesUtilizationInfo
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetVgpuInstancesUtilizationInfo == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6835, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6836
 *     global __nvmlDeviceGetVgpuInstancesUtilizationInfo
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuInstancesUtilizationInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuInstancesUtilizationInfo is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuInstancesUtilizationInfo == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6837
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuInstancesUtilizationInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuInstancesUtilizationInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuInstancesUtilizationInfo_t*) noexcept nogil>__nvmlDeviceGetVgpuInstancesUtilizationInfo)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6838
 *     if __nvmlDeviceGetVgpuInstancesUtilizationInfo == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuInstancesUtilizationInfo is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuInstancesUtilizationInfo_t*) noexcept nogil>__nvmlDeviceGetVgpuInstancesUtilizationInfo)(
 *         device, vgpuUtilInfo)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6838, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetVgpuInstan};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6838, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6838, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6837
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuInstancesUtilizationInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuInstancesUtilizationInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuInstancesUtilizationInfo_t*) noexcept nogil>__nvmlDeviceGetVgpuInstancesUtilizationInfo)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6836
 *     global __nvmlDeviceGetVgpuInstancesUtilizationInfo
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuInstancesUtilizationInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuInstancesUtilizationInfo is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6839
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuInstancesUtilizationInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuInstancesUtilizationInfo_t*) noexcept nogil>__nvmlDeviceGetVgpuInstancesUtilizationInfo)(             # <<<<<<<<<<<<<<
 *         device, vgpuUtilInfo)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuInstancesUtilizationInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuInstancesUtilizationInfo)(__pyx_v_device, __pyx_v_vgpuUtilInfo);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6833
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuInstancesUtilizationInfo(nvmlDevice_t device, nvmlVgpuInstancesUtilizationInfo_t* vgpuUtilInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVgpuInstancesUtilizationInfo
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetVgpuInstancesUtilizationInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6843
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuProcessUtilization(nvmlDevice_t device, unsigned long long lastSeenTimeStamp, unsigned int* vgpuProcessSamplesCount, nvmlVgpuProcessUtilizationSample_t* utilizationSamples) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVgpuProcessUtilization
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVgpuProcessUtilization(nvmlDevice_t __pyx_v_device, unsigned PY_LONG_LONG __pyx_v_lastSeenTimeStamp, unsigned int *__pyx_v_vgpuProcessSamplesCount, nvmlVgpuProcessUtilizationSample_t *__pyx_v_utilizationSamples) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetVgpuProcessUtilization", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6845
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuProcessUtilization(nvmlDevice_t device, unsigned long long lastSeenTimeStamp, unsigned int* vgpuProcessSamplesCount, nvmlVgpuProcessUtilizationSample_t* utilizationSamples) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetVgpuProcessUtilization
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetVgpuProcessUtilization == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6845, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6846
 *     global __nvmlDeviceGetVgpuProcessUtilization
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuProcessUtilization == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuProcessUtilization is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuProcessUtilization == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6847
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuProcessUtilization == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuProcessUtilization is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long, unsigned int*, nvmlVgpuProcessUtilizationSample_t*) noexcept nogil>__nvmlDeviceGetVgpuProcessUtilization)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6848
 *     if __nvmlDeviceGetVgpuProcessUtilization == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuProcessUtilization is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long, unsigned int*, nvmlVgpuProcessUtilizationSample_t*) noexcept nogil>__nvmlDeviceGetVgpuProcessUtilization)(
 *         device, lastSeenTimeStamp, vgpuProcessSamplesCount, utilizationSamples)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6848, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetVgpuProces};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6848, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6848, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6847
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuProcessUtilization == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuProcessUtilization is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long, unsigned int*, nvmlVgpuProcessUtilizationSample_t*) noexcept nogil>__nvmlDeviceGetVgpuProcessUtilization)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6846
 *     global __nvmlDeviceGetVgpuProcessUtilization
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuProcessUtilization == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuProcessUtilization is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6849
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuProcessUtilization is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned long long, unsigned int*, nvmlVgpuProcessUtilizationSample_t*) noexcept nogil>__nvmlDeviceGetVgpuProcessUtilization)(             # <<<<<<<<<<<<<<
 *         device, lastSeenTimeStamp, vgpuProcessSamplesCount, utilizationSamples)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned PY_LONG_LONG, unsigned int *, nvmlVgpuProcessUtilizationSample_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuProcessUtilization)(__pyx_v_device, __pyx_v_lastSeenTimeStamp, __pyx_v_vgpuProcessSamplesCount, __pyx_v_utilizationSamples);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6843
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuProcessUtilization(nvmlDevice_t device, unsigned long long lastSeenTimeStamp, unsigned int* vgpuProcessSamplesCount, nvmlVgpuProcessUtilizationSample_t* utilizationSamples) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVgpuProcessUtilization
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetVgpuProcessUtilization", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6853
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuProcessesUtilizationInfo(nvmlDevice_t device, nvmlVgpuProcessesUtilizationInfo_t* vgpuProcUtilInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVgpuProcessesUtilizationInfo
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVgpuProcessesUtilizationInfo(nvmlDevice_t __pyx_v_device, nvmlVgpuProcessesUtilizationInfo_t *__pyx_v_vgpuProcUtilInfo) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetVgpuProcessesUtilizationInfo", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6855
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuProcessesUtilizationInfo(nvmlDevice_t device, nvmlVgpuProcessesUtilizationInfo_t* vgpuProcUtilInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetVgpuProcessesUtilizationInfo
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetVgpuProcessesUtilizationInfo == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6855, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6856
 *     global __nvmlDeviceGetVgpuProcessesUtilizationInfo
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuProcessesUtilizationInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuProcessesUtilizationInfo is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuProcessesUtilizationInfo == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6857
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuProcessesUtilizationInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuProcessesUtilizationInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuProcessesUtilizationInfo_t*) noexcept nogil>__nvmlDeviceGetVgpuProcessesUtilizationInfo)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6858
 *     if __nvmlDeviceGetVgpuProcessesUtilizationInfo == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuProcessesUtilizationInfo is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuProcessesUtilizationInfo_t*) noexcept nogil>__nvmlDeviceGetVgpuProcessesUtilizationInfo)(
 *         device, vgpuProcUtilInfo)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6858, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetVgpuProces_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6858, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6858, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6857
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuProcessesUtilizationInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuProcessesUtilizationInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuProcessesUtilizationInfo_t*) noexcept nogil>__nvmlDeviceGetVgpuProcessesUtilizationInfo)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6856
 *     global __nvmlDeviceGetVgpuProcessesUtilizationInfo
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetVgpuProcessesUtilizationInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuProcessesUtilizationInfo is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6859
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetVgpuProcessesUtilizationInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuProcessesUtilizationInfo_t*) noexcept nogil>__nvmlDeviceGetVgpuProcessesUtilizationInfo)(             # <<<<<<<<<<<<<<
 *         device, vgpuProcUtilInfo)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlVgpuProcessesUtilizationInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuProcessesUtilizationInfo)(__pyx_v_device, __pyx_v_vgpuProcUtilInfo);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6853
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetVgpuProcessesUtilizationInfo(nvmlDevice_t device, nvmlVgpuProcessesUtilizationInfo_t* vgpuProcUtilInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetVgpuProcessesUtilizationInfo
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetVgpuProcessesUtilizationInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6863
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetAccountingMode(nvmlVgpuInstance_t vgpuInstance, nvmlEnableState_t* mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetAccountingMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetAccountingMode(nvmlVgpuInstance_t __pyx_v_vgpuInstance, nvmlEnableState_t *__pyx_v_mode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceGetAccountingMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6865
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetAccountingMode(nvmlVgpuInstance_t vgpuInstance, nvmlEnableState_t* mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceGetAccountingMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceGetAccountingMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6865, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6866
 *     global __nvmlVgpuInstanceGetAccountingMode
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetAccountingMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetAccountingMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetAccountingMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6867
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetAccountingMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetAccountingMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlEnableState_t*) noexcept nogil>__nvmlVgpuInstanceGetAccountingMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6868
 *     if __nvmlVgpuInstanceGetAccountingMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetAccountingMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlEnableState_t*) noexcept nogil>__nvmlVgpuInstanceGetAccountingMode)(
 *         vgpuInstance, mode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6868, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceGetAcco};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6868, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6868, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6867
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetAccountingMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetAccountingMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlEnableState_t*) noexcept nogil>__nvmlVgpuInstanceGetAccountingMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6866
 *     global __nvmlVgpuInstanceGetAccountingMode
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetAccountingMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetAccountingMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6869
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetAccountingMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlEnableState_t*) noexcept nogil>__nvmlVgpuInstanceGetAccountingMode)(             # <<<<<<<<<<<<<<
 *         vgpuInstance, mode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlEnableState_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetAccountingMode)(__pyx_v_vgpuInstance, __pyx_v_mode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6863
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetAccountingMode(nvmlVgpuInstance_t vgpuInstance, nvmlEnableState_t* mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetAccountingMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceGetAccountingMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6873
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetAccountingPids(nvmlVgpuInstance_t vgpuInstance, unsigned int* count, unsigned int* pids) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetAccountingPids
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetAccountingPids(nvmlVgpuInstance_t __pyx_v_vgpuInstance, unsigned int *__pyx_v_count, unsigned int *__pyx_v_pids) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceGetAccountingPids", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6875
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetAccountingPids(nvmlVgpuInstance_t vgpuInstance, unsigned int* count, unsigned int* pids) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceGetAccountingPids
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceGetAccountingPids == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6875, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6876
 *     global __nvmlVgpuInstanceGetAccountingPids
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetAccountingPids == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetAccountingPids is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetAccountingPids == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6877
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetAccountingPids == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetAccountingPids is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetAccountingPids)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6878
 *     if __nvmlVgpuInstanceGetAccountingPids == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetAccountingPids is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetAccountingPids)(
 *         vgpuInstance, count, pids)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6878, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceGetAcco_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6878, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6878, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6877
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetAccountingPids == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetAccountingPids is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetAccountingPids)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6876
 *     global __nvmlVgpuInstanceGetAccountingPids
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetAccountingPids == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetAccountingPids is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6879
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetAccountingPids is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlVgpuInstanceGetAccountingPids)(             # <<<<<<<<<<<<<<
 *         vgpuInstance, count, pids)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetAccountingPids)(__pyx_v_vgpuInstance, __pyx_v_count, __pyx_v_pids);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6873
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetAccountingPids(nvmlVgpuInstance_t vgpuInstance, unsigned int* count, unsigned int* pids) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetAccountingPids
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceGetAccountingPids", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6883
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetAccountingStats(nvmlVgpuInstance_t vgpuInstance, unsigned int pid, nvmlAccountingStats_t* stats) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetAccountingStats
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetAccountingStats(nvmlVgpuInstance_t __pyx_v_vgpuInstance, unsigned int __pyx_v_pid, nvmlAccountingStats_t *__pyx_v_stats) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceGetAccountingStats", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6885
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetAccountingStats(nvmlVgpuInstance_t vgpuInstance, unsigned int pid, nvmlAccountingStats_t* stats) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceGetAccountingStats
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceGetAccountingStats == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6885, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6886
 *     global __nvmlVgpuInstanceGetAccountingStats
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetAccountingStats == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetAccountingStats is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetAccountingStats == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6887
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetAccountingStats == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetAccountingStats is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int, nvmlAccountingStats_t*) noexcept nogil>__nvmlVgpuInstanceGetAccountingStats)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6888
 *     if __nvmlVgpuInstanceGetAccountingStats == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetAccountingStats is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int, nvmlAccountingStats_t*) noexcept nogil>__nvmlVgpuInstanceGetAccountingStats)(
 *         vgpuInstance, pid, stats)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6888, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceGetAcco_3};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6888, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6888, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6887
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetAccountingStats == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetAccountingStats is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int, nvmlAccountingStats_t*) noexcept nogil>__nvmlVgpuInstanceGetAccountingStats)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6886
 *     global __nvmlVgpuInstanceGetAccountingStats
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetAccountingStats == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetAccountingStats is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6889
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetAccountingStats is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int, nvmlAccountingStats_t*) noexcept nogil>__nvmlVgpuInstanceGetAccountingStats)(             # <<<<<<<<<<<<<<
 *         vgpuInstance, pid, stats)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t, unsigned int, nvmlAccountingStats_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetAccountingStats)(__pyx_v_vgpuInstance, __pyx_v_pid, __pyx_v_stats);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6883
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetAccountingStats(nvmlVgpuInstance_t vgpuInstance, unsigned int pid, nvmlAccountingStats_t* stats) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetAccountingStats
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceGetAccountingStats", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6893
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceClearAccountingPids(nvmlVgpuInstance_t vgpuInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceClearAccountingPids
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceClearAccountingPids(nvmlVgpuInstance_t __pyx_v_vgpuInstance) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceClearAccountingPids", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6895
 * cdef nvmlReturn_t _nvmlVgpuInstanceClearAccountingPids(nvmlVgpuInstance_t vgpuInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceClearAccountingPids
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceClearAccountingPids == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6895, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6896
 *     global __nvmlVgpuInstanceClearAccountingPids
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceClearAccountingPids == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceClearAccountingPids is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceClearAccountingPids == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6897
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceClearAccountingPids == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceClearAccountingPids is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t) noexcept nogil>__nvmlVgpuInstanceClearAccountingPids)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6898
 *     if __nvmlVgpuInstanceClearAccountingPids == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceClearAccountingPids is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t) noexcept nogil>__nvmlVgpuInstanceClearAccountingPids)(
 *         vgpuInstance)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6898, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceClearAc};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6898, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6898, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6897
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceClearAccountingPids == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceClearAccountingPids is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t) noexcept nogil>__nvmlVgpuInstanceClearAccountingPids)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6896
 *     global __nvmlVgpuInstanceClearAccountingPids
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceClearAccountingPids == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceClearAccountingPids is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6899
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceClearAccountingPids is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t) noexcept nogil>__nvmlVgpuInstanceClearAccountingPids)(             # <<<<<<<<<<<<<<
 *         vgpuInstance)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceClearAccountingPids)(__pyx_v_vgpuInstance);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6893
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceClearAccountingPids(nvmlVgpuInstance_t vgpuInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceClearAccountingPids
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceClearAccountingPids", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6903
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetLicenseInfo_v2(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuLicenseInfo_t* licenseInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetLicenseInfo_v2
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetLicenseInfo_v2(nvmlVgpuInstance_t __pyx_v_vgpuInstance, nvmlVgpuLicenseInfo_t *__pyx_v_licenseInfo) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlVgpuInstanceGetLicenseInfo_v2", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6905
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetLicenseInfo_v2(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuLicenseInfo_t* licenseInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlVgpuInstanceGetLicenseInfo_v2
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlVgpuInstanceGetLicenseInfo_v2 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6905, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6906
 *     global __nvmlVgpuInstanceGetLicenseInfo_v2
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetLicenseInfo_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetLicenseInfo_v2 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetLicenseInfo_v2 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6907
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetLicenseInfo_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetLicenseInfo_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuLicenseInfo_t*) noexcept nogil>__nvmlVgpuInstanceGetLicenseInfo_v2)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6908
 *     if __nvmlVgpuInstanceGetLicenseInfo_v2 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetLicenseInfo_v2 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuLicenseInfo_t*) noexcept nogil>__nvmlVgpuInstanceGetLicenseInfo_v2)(
 *         vgpuInstance, licenseInfo)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6908, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlVgpuInstanceGetLice_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6908, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6908, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6907
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetLicenseInfo_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetLicenseInfo_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuLicenseInfo_t*) noexcept nogil>__nvmlVgpuInstanceGetLicenseInfo_v2)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6906
 *     global __nvmlVgpuInstanceGetLicenseInfo_v2
 *     _check_or_init_nvml()
 *     if __nvmlVgpuInstanceGetLicenseInfo_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetLicenseInfo_v2 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6909
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlVgpuInstanceGetLicenseInfo_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuLicenseInfo_t*) noexcept nogil>__nvmlVgpuInstanceGetLicenseInfo_v2)(             # <<<<<<<<<<<<<<
 *         vgpuInstance, licenseInfo)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlVgpuInstance_t, nvmlVgpuLicenseInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetLicenseInfo_v2)(__pyx_v_vgpuInstance, __pyx_v_licenseInfo);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6903
 * 
 * 
 * cdef nvmlReturn_t _nvmlVgpuInstanceGetLicenseInfo_v2(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuLicenseInfo_t* licenseInfo) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlVgpuInstanceGetLicenseInfo_v2
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlVgpuInstanceGetLicenseInfo_v2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6913
 * 
 * 
 * cdef nvmlReturn_t _nvmlGetExcludedDeviceCount(unsigned int* deviceCount) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGetExcludedDeviceCount
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGetExcludedDeviceCount(unsigned int *__pyx_v_deviceCount) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGetExcludedDeviceCount", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6915
 * cdef nvmlReturn_t _nvmlGetExcludedDeviceCount(unsigned int* deviceCount) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGetExcludedDeviceCount
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGetExcludedDeviceCount == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6915, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6916
 *     global __nvmlGetExcludedDeviceCount
 *     _check_or_init_nvml()
 *     if __nvmlGetExcludedDeviceCount == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGetExcludedDeviceCount is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetExcludedDeviceCount == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6917
 *     _check_or_init_nvml()
 *     if __nvmlGetExcludedDeviceCount == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGetExcludedDeviceCount is not found")
 *     return (<nvmlReturn_t (*)(unsigned int*) noexcept nogil>__nvmlGetExcludedDeviceCount)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6918
 *     if __nvmlGetExcludedDeviceCount == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGetExcludedDeviceCount is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(unsigned int*) noexcept nogil>__nvmlGetExcludedDeviceCount)(
 *         deviceCount)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6918, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGetExcludedDeviceCo};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6918, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6918, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6917
 *     _check_or_init_nvml()
 *     if __nvmlGetExcludedDeviceCount == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGetExcludedDeviceCount is not found")
 *     return (<nvmlReturn_t (*)(unsigned int*) noexcept nogil>__nvmlGetExcludedDeviceCount)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6916
 *     global __nvmlGetExcludedDeviceCount
 *     _check_or_init_nvml()
 *     if __nvmlGetExcludedDeviceCount == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGetExcludedDeviceCount is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6919
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGetExcludedDeviceCount is not found")
 *     return (<nvmlReturn_t (*)(unsigned int*) noexcept nogil>__nvmlGetExcludedDeviceCount)(             # <<<<<<<<<<<<<<
 *         deviceCount)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetExcludedDeviceCount)(__pyx_v_deviceCount);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6913
 * 
 * 
 * cdef nvmlReturn_t _nvmlGetExcludedDeviceCount(unsigned int* deviceCount) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGetExcludedDeviceCount
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGetExcludedDeviceCount", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6923
 * 
 * 
 * cdef nvmlReturn_t _nvmlGetExcludedDeviceInfoByIndex(unsigned int index, nvmlExcludedDeviceInfo_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGetExcludedDeviceInfoByIndex
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGetExcludedDeviceInfoByIndex(unsigned int __pyx_v_index, nvmlExcludedDeviceInfo_t *__pyx_v_info) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGetExcludedDeviceInfoByIndex", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6925
 * cdef nvmlReturn_t _nvmlGetExcludedDeviceInfoByIndex(unsigned int index, nvmlExcludedDeviceInfo_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGetExcludedDeviceInfoByIndex
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGetExcludedDeviceInfoByIndex == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6925, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6926
 *     global __nvmlGetExcludedDeviceInfoByIndex
 *     _check_or_init_nvml()
 *     if __nvmlGetExcludedDeviceInfoByIndex == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGetExcludedDeviceInfoByIndex is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetExcludedDeviceInfoByIndex == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6927
 *     _check_or_init_nvml()
 *     if __nvmlGetExcludedDeviceInfoByIndex == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGetExcludedDeviceInfoByIndex is not found")
 *     return (<nvmlReturn_t (*)(unsigned int, nvmlExcludedDeviceInfo_t*) noexcept nogil>__nvmlGetExcludedDeviceInfoByIndex)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6928
 *     if __nvmlGetExcludedDeviceInfoByIndex == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGetExcludedDeviceInfoByIndex is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(unsigned int, nvmlExcludedDeviceInfo_t*) noexcept nogil>__nvmlGetExcludedDeviceInfoByIndex)(
 *         index, info)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6928, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGetExcludedDeviceIn};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6928, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6928, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6927
 *     _check_or_init_nvml()
 *     if __nvmlGetExcludedDeviceInfoByIndex == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGetExcludedDeviceInfoByIndex is not found")
 *     return (<nvmlReturn_t (*)(unsigned int, nvmlExcludedDeviceInfo_t*) noexcept nogil>__nvmlGetExcludedDeviceInfoByIndex)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6926
 *     global __nvmlGetExcludedDeviceInfoByIndex
 *     _check_or_init_nvml()
 *     if __nvmlGetExcludedDeviceInfoByIndex == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGetExcludedDeviceInfoByIndex is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6929
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGetExcludedDeviceInfoByIndex is not found")
 *     return (<nvmlReturn_t (*)(unsigned int, nvmlExcludedDeviceInfo_t*) noexcept nogil>__nvmlGetExcludedDeviceInfoByIndex)(             # <<<<<<<<<<<<<<
 *         index, info)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(unsigned int, nvmlExcludedDeviceInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetExcludedDeviceInfoByIndex)(__pyx_v_index, __pyx_v_info);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6923
 * 
 * 
 * cdef nvmlReturn_t _nvmlGetExcludedDeviceInfoByIndex(unsigned int index, nvmlExcludedDeviceInfo_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGetExcludedDeviceInfoByIndex
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGetExcludedDeviceInfoByIndex", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6933
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetMigMode(nvmlDevice_t device, unsigned int mode, nvmlReturn_t* activationStatus) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetMigMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetMigMode(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_mode, nvmlReturn_t *__pyx_v_activationStatus) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetMigMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6935
 * cdef nvmlReturn_t _nvmlDeviceSetMigMode(nvmlDevice_t device, unsigned int mode, nvmlReturn_t* activationStatus) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetMigMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetMigMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6935, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6936
 *     global __nvmlDeviceSetMigMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetMigMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetMigMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetMigMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6937
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetMigMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetMigMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlReturn_t*) noexcept nogil>__nvmlDeviceSetMigMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6938
 *     if __nvmlDeviceSetMigMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetMigMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlReturn_t*) noexcept nogil>__nvmlDeviceSetMigMode)(
 *         device, mode, activationStatus)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6938, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetMigMode_is};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6938, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6938, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6937
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetMigMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetMigMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlReturn_t*) noexcept nogil>__nvmlDeviceSetMigMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6936
 *     global __nvmlDeviceSetMigMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetMigMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetMigMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6939
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetMigMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlReturn_t*) noexcept nogil>__nvmlDeviceSetMigMode)(             # <<<<<<<<<<<<<<
 *         device, mode, activationStatus)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlReturn_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetMigMode)(__pyx_v_device, __pyx_v_mode, __pyx_v_activationStatus);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6933
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetMigMode(nvmlDevice_t device, unsigned int mode, nvmlReturn_t* activationStatus) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetMigMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetMigMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6943
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMigMode(nvmlDevice_t device, unsigned int* currentMode, unsigned int* pendingMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMigMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMigMode(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_currentMode, unsigned int *__pyx_v_pendingMode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetMigMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6945
 * cdef nvmlReturn_t _nvmlDeviceGetMigMode(nvmlDevice_t device, unsigned int* currentMode, unsigned int* pendingMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetMigMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetMigMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6945, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6946
 *     global __nvmlDeviceGetMigMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMigMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMigMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMigMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6947
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMigMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMigMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetMigMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6948
 *     if __nvmlDeviceGetMigMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMigMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetMigMode)(
 *         device, currentMode, pendingMode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6948, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetMigMode_is};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6948, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6948, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6947
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMigMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMigMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetMigMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6946
 *     global __nvmlDeviceGetMigMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMigMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMigMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6949
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMigMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*, unsigned int*) noexcept nogil>__nvmlDeviceGetMigMode)(             # <<<<<<<<<<<<<<
 *         device, currentMode, pendingMode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMigMode)(__pyx_v_device, __pyx_v_currentMode, __pyx_v_pendingMode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6943
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMigMode(nvmlDevice_t device, unsigned int* currentMode, unsigned int* pendingMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMigMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetMigMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6953
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGpuInstanceProfileInfoV(nvmlDevice_t device, unsigned int profile, nvmlGpuInstanceProfileInfo_v2_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGpuInstanceProfileInfoV
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGpuInstanceProfileInfoV(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_profile, nvmlGpuInstanceProfileInfo_v2_t *__pyx_v_info) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetGpuInstanceProfileInfoV", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6955
 * cdef nvmlReturn_t _nvmlDeviceGetGpuInstanceProfileInfoV(nvmlDevice_t device, unsigned int profile, nvmlGpuInstanceProfileInfo_v2_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetGpuInstanceProfileInfoV
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetGpuInstanceProfileInfoV == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6955, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6956
 *     global __nvmlDeviceGetGpuInstanceProfileInfoV
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstanceProfileInfoV == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceProfileInfoV is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceProfileInfoV == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6957
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstanceProfileInfoV == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceProfileInfoV is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstanceProfileInfo_v2_t*) noexcept nogil>__nvmlDeviceGetGpuInstanceProfileInfoV)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6958
 *     if __nvmlDeviceGetGpuInstanceProfileInfoV == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceProfileInfoV is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstanceProfileInfo_v2_t*) noexcept nogil>__nvmlDeviceGetGpuInstanceProfileInfoV)(
 *         device, profile, info)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6958, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetGpuInstanc};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6958, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6958, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6957
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstanceProfileInfoV == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceProfileInfoV is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstanceProfileInfo_v2_t*) noexcept nogil>__nvmlDeviceGetGpuInstanceProfileInfoV)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6956
 *     global __nvmlDeviceGetGpuInstanceProfileInfoV
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstanceProfileInfoV == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceProfileInfoV is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6959
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceProfileInfoV is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstanceProfileInfo_v2_t*) noexcept nogil>__nvmlDeviceGetGpuInstanceProfileInfoV)(             # <<<<<<<<<<<<<<
 *         device, profile, info)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstanceProfileInfo_v2_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceProfileInfoV)(__pyx_v_device, __pyx_v_profile, __pyx_v_info);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6953
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGpuInstanceProfileInfoV(nvmlDevice_t device, unsigned int profile, nvmlGpuInstanceProfileInfo_v2_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGpuInstanceProfileInfoV
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetGpuInstanceProfileInfoV", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6963
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGpuInstancePossiblePlacements_v2(nvmlDevice_t device, unsigned int profileId, nvmlGpuInstancePlacement_t* placements, unsigned int* count) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGpuInstancePossiblePlacements_v2
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGpuInstancePossiblePlacements_v2(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_profileId, nvmlGpuInstancePlacement_t *__pyx_v_placements, unsigned int *__pyx_v_count) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetGpuInstancePossiblePlacements_v2", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6965
 * cdef nvmlReturn_t _nvmlDeviceGetGpuInstancePossiblePlacements_v2(nvmlDevice_t device, unsigned int profileId, nvmlGpuInstancePlacement_t* placements, unsigned int* count) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetGpuInstancePossiblePlacements_v2
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetGpuInstancePossiblePlacements_v2 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6965, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6966
 *     global __nvmlDeviceGetGpuInstancePossiblePlacements_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstancePossiblePlacements_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstancePossiblePlacements_v2 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstancePossiblePlacements_v2 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6967
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstancePossiblePlacements_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstancePossiblePlacements_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstancePlacement_t*, unsigned int*) noexcept nogil>__nvmlDeviceGetGpuInstancePossiblePlacements_v2)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6968
 *     if __nvmlDeviceGetGpuInstancePossiblePlacements_v2 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstancePossiblePlacements_v2 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstancePlacement_t*, unsigned int*) noexcept nogil>__nvmlDeviceGetGpuInstancePossiblePlacements_v2)(
 *         device, profileId, placements, count)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6968, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetGpuInstanc_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6968, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6968, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6967
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstancePossiblePlacements_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstancePossiblePlacements_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstancePlacement_t*, unsigned int*) noexcept nogil>__nvmlDeviceGetGpuInstancePossiblePlacements_v2)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6966
 *     global __nvmlDeviceGetGpuInstancePossiblePlacements_v2
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstancePossiblePlacements_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstancePossiblePlacements_v2 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6969
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstancePossiblePlacements_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstancePlacement_t*, unsigned int*) noexcept nogil>__nvmlDeviceGetGpuInstancePossiblePlacements_v2)(             # <<<<<<<<<<<<<<
 *         device, profileId, placements, count)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstancePlacement_t *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstancePossiblePlacements_v2)(__pyx_v_device, __pyx_v_profileId, __pyx_v_placements, __pyx_v_count);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6963
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGpuInstancePossiblePlacements_v2(nvmlDevice_t device, unsigned int profileId, nvmlGpuInstancePlacement_t* placements, unsigned int* count) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGpuInstancePossiblePlacements_v2
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetGpuInstancePossiblePlacements_v2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6973
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGpuInstanceRemainingCapacity(nvmlDevice_t device, unsigned int profileId, unsigned int* count) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGpuInstanceRemainingCapacity
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGpuInstanceRemainingCapacity(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_profileId, unsigned int *__pyx_v_count) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetGpuInstanceRemainingCapacity", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6975
 * cdef nvmlReturn_t _nvmlDeviceGetGpuInstanceRemainingCapacity(nvmlDevice_t device, unsigned int profileId, unsigned int* count) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetGpuInstanceRemainingCapacity
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetGpuInstanceRemainingCapacity == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6975, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6976
 *     global __nvmlDeviceGetGpuInstanceRemainingCapacity
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstanceRemainingCapacity == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceRemainingCapacity is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceRemainingCapacity == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6977
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstanceRemainingCapacity == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceRemainingCapacity is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int*) noexcept nogil>__nvmlDeviceGetGpuInstanceRemainingCapacity)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6978
 *     if __nvmlDeviceGetGpuInstanceRemainingCapacity == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceRemainingCapacity is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int*) noexcept nogil>__nvmlDeviceGetGpuInstanceRemainingCapacity)(
 *         device, profileId, count)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6978, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetGpuInstanc_3};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6978, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6978, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6977
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstanceRemainingCapacity == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceRemainingCapacity is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int*) noexcept nogil>__nvmlDeviceGetGpuInstanceRemainingCapacity)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6976
 *     global __nvmlDeviceGetGpuInstanceRemainingCapacity
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstanceRemainingCapacity == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceRemainingCapacity is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6979
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceRemainingCapacity is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int*) noexcept nogil>__nvmlDeviceGetGpuInstanceRemainingCapacity)(             # <<<<<<<<<<<<<<
 *         device, profileId, count)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceRemainingCapacity)(__pyx_v_device, __pyx_v_profileId, __pyx_v_count);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6973
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGpuInstanceRemainingCapacity(nvmlDevice_t device, unsigned int profileId, unsigned int* count) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGpuInstanceRemainingCapacity
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetGpuInstanceRemainingCapacity", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6983
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceCreateGpuInstance(nvmlDevice_t device, unsigned int profileId, nvmlGpuInstance_t* gpuInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceCreateGpuInstance
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceCreateGpuInstance(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_profileId, nvmlGpuInstance_t *__pyx_v_gpuInstance) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceCreateGpuInstance", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6985
 * cdef nvmlReturn_t _nvmlDeviceCreateGpuInstance(nvmlDevice_t device, unsigned int profileId, nvmlGpuInstance_t* gpuInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceCreateGpuInstance
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceCreateGpuInstance == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6985, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6986
 *     global __nvmlDeviceCreateGpuInstance
 *     _check_or_init_nvml()
 *     if __nvmlDeviceCreateGpuInstance == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceCreateGpuInstance is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceCreateGpuInstance == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6987
 *     _check_or_init_nvml()
 *     if __nvmlDeviceCreateGpuInstance == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceCreateGpuInstance is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstance_t*) noexcept nogil>__nvmlDeviceCreateGpuInstance)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6988
 *     if __nvmlDeviceCreateGpuInstance == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceCreateGpuInstance is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstance_t*) noexcept nogil>__nvmlDeviceCreateGpuInstance)(
 *         device, profileId, gpuInstance)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6988, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceCreateGpuInst};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6988, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6988, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6987
 *     _check_or_init_nvml()
 *     if __nvmlDeviceCreateGpuInstance == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceCreateGpuInstance is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstance_t*) noexcept nogil>__nvmlDeviceCreateGpuInstance)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6986
 *     global __nvmlDeviceCreateGpuInstance
 *     _check_or_init_nvml()
 *     if __nvmlDeviceCreateGpuInstance == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceCreateGpuInstance is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6989
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceCreateGpuInstance is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstance_t*) noexcept nogil>__nvmlDeviceCreateGpuInstance)(             # <<<<<<<<<<<<<<
 *         device, profileId, gpuInstance)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstance_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceCreateGpuInstance)(__pyx_v_device, __pyx_v_profileId, __pyx_v_gpuInstance);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6983
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceCreateGpuInstance(nvmlDevice_t device, unsigned int profileId, nvmlGpuInstance_t* gpuInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceCreateGpuInstance
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceCreateGpuInstance", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":6993
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceCreateGpuInstanceWithPlacement(nvmlDevice_t device, unsigned int profileId, const nvmlGpuInstancePlacement_t* placement, nvmlGpuInstance_t* gpuInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceCreateGpuInstanceWithPlacement
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceCreateGpuInstanceWithPlacement(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_profileId, nvmlGpuInstancePlacement_t const *__pyx_v_placement, nvmlGpuInstance_t *__pyx_v_gpuInstance) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceCreateGpuInstanceWithPlacement", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":6995
 * cdef nvmlReturn_t _nvmlDeviceCreateGpuInstanceWithPlacement(nvmlDevice_t device, unsigned int profileId, const nvmlGpuInstancePlacement_t* placement, nvmlGpuInstance_t* gpuInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceCreateGpuInstanceWithPlacement
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceCreateGpuInstanceWithPlacement == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 6995, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":6996
 *     global __nvmlDeviceCreateGpuInstanceWithPlacement
 *     _check_or_init_nvml()
 *     if __nvmlDeviceCreateGpuInstanceWithPlacement == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceCreateGpuInstanceWithPlacement is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceCreateGpuInstanceWithPlacement == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":6997
 *     _check_or_init_nvml()
 *     if __nvmlDeviceCreateGpuInstanceWithPlacement == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceCreateGpuInstanceWithPlacement is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, const nvmlGpuInstancePlacement_t*, nvmlGpuInstance_t*) noexcept nogil>__nvmlDeviceCreateGpuInstanceWithPlacement)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":6998
 *     if __nvmlDeviceCreateGpuInstanceWithPlacement == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceCreateGpuInstanceWithPlacement is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, const nvmlGpuInstancePlacement_t*, nvmlGpuInstance_t*) noexcept nogil>__nvmlDeviceCreateGpuInstanceWithPlacement)(
 *         device, profileId, placement, gpuInstance)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6998, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceCreateGpuInst_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6998, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 6998, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":6997
 *     _check_or_init_nvml()
 *     if __nvmlDeviceCreateGpuInstanceWithPlacement == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceCreateGpuInstanceWithPlacement is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, const nvmlGpuInstancePlacement_t*, nvmlGpuInstance_t*) noexcept nogil>__nvmlDeviceCreateGpuInstanceWithPlacement)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":6996
 *     global __nvmlDeviceCreateGpuInstanceWithPlacement
 *     _check_or_init_nvml()
 *     if __nvmlDeviceCreateGpuInstanceWithPlacement == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceCreateGpuInstanceWithPlacement is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":6999
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceCreateGpuInstanceWithPlacement is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, const nvmlGpuInstancePlacement_t*, nvmlGpuInstance_t*) noexcept nogil>__nvmlDeviceCreateGpuInstanceWithPlacement)(             # <<<<<<<<<<<<<<
 *         device, profileId, placement, gpuInstance)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstancePlacement_t const *, nvmlGpuInstance_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceCreateGpuInstanceWithPlacement)(__pyx_v_device, __pyx_v_profileId, __pyx_v_placement, __pyx_v_gpuInstance);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":6993
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceCreateGpuInstanceWithPlacement(nvmlDevice_t device, unsigned int profileId, const nvmlGpuInstancePlacement_t* placement, nvmlGpuInstance_t* gpuInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceCreateGpuInstanceWithPlacement
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceCreateGpuInstanceWithPlacement", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7003
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceDestroy(nvmlGpuInstance_t gpuInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceDestroy
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceDestroy(nvmlGpuInstance_t __pyx_v_gpuInstance) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGpuInstanceDestroy", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7005
 * cdef nvmlReturn_t _nvmlGpuInstanceDestroy(nvmlGpuInstance_t gpuInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGpuInstanceDestroy
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGpuInstanceDestroy == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7005, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7006
 *     global __nvmlGpuInstanceDestroy
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceDestroy == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceDestroy is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceDestroy == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7007
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceDestroy == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceDestroy is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t) noexcept nogil>__nvmlGpuInstanceDestroy)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7008
 *     if __nvmlGpuInstanceDestroy == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceDestroy is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t) noexcept nogil>__nvmlGpuInstanceDestroy)(
 *         gpuInstance)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7008, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGpuInstanceDestroy};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7008, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7008, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7007
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceDestroy == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceDestroy is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t) noexcept nogil>__nvmlGpuInstanceDestroy)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7006
 *     global __nvmlGpuInstanceDestroy
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceDestroy == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceDestroy is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7009
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceDestroy is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t) noexcept nogil>__nvmlGpuInstanceDestroy)(             # <<<<<<<<<<<<<<
 *         gpuInstance)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlGpuInstance_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceDestroy)(__pyx_v_gpuInstance);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7003
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceDestroy(nvmlGpuInstance_t gpuInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceDestroy
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGpuInstanceDestroy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7013
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGpuInstances(nvmlDevice_t device, unsigned int profileId, nvmlGpuInstance_t* gpuInstances, unsigned int* count) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGpuInstances
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGpuInstances(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_profileId, nvmlGpuInstance_t *__pyx_v_gpuInstances, unsigned int *__pyx_v_count) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetGpuInstances", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7015
 * cdef nvmlReturn_t _nvmlDeviceGetGpuInstances(nvmlDevice_t device, unsigned int profileId, nvmlGpuInstance_t* gpuInstances, unsigned int* count) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetGpuInstances
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetGpuInstances == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7015, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7016
 *     global __nvmlDeviceGetGpuInstances
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstances == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstances is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstances == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7017
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstances == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstances is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstance_t*, unsigned int*) noexcept nogil>__nvmlDeviceGetGpuInstances)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7018
 *     if __nvmlDeviceGetGpuInstances == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstances is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstance_t*, unsigned int*) noexcept nogil>__nvmlDeviceGetGpuInstances)(
 *         device, profileId, gpuInstances, count)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7018, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetGpuInstanc_4};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7018, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7018, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7017
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstances == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstances is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstance_t*, unsigned int*) noexcept nogil>__nvmlDeviceGetGpuInstances)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7016
 *     global __nvmlDeviceGetGpuInstances
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstances == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstances is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7019
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstances is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstance_t*, unsigned int*) noexcept nogil>__nvmlDeviceGetGpuInstances)(             # <<<<<<<<<<<<<<
 *         device, profileId, gpuInstances, count)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstance_t *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstances)(__pyx_v_device, __pyx_v_profileId, __pyx_v_gpuInstances, __pyx_v_count);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7013
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGpuInstances(nvmlDevice_t device, unsigned int profileId, nvmlGpuInstance_t* gpuInstances, unsigned int* count) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGpuInstances
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetGpuInstances", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7023
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGpuInstanceById(nvmlDevice_t device, unsigned int id, nvmlGpuInstance_t* gpuInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGpuInstanceById
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGpuInstanceById(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_id, nvmlGpuInstance_t *__pyx_v_gpuInstance) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetGpuInstanceById", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7025
 * cdef nvmlReturn_t _nvmlDeviceGetGpuInstanceById(nvmlDevice_t device, unsigned int id, nvmlGpuInstance_t* gpuInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetGpuInstanceById
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetGpuInstanceById == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7025, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7026
 *     global __nvmlDeviceGetGpuInstanceById
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstanceById == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceById is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceById == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7027
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstanceById == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceById is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstance_t*) noexcept nogil>__nvmlDeviceGetGpuInstanceById)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7028
 *     if __nvmlDeviceGetGpuInstanceById == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceById is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstance_t*) noexcept nogil>__nvmlDeviceGetGpuInstanceById)(
 *         device, id, gpuInstance)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7028, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetGpuInstanc_5};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7028, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7028, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7027
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstanceById == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceById is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstance_t*) noexcept nogil>__nvmlDeviceGetGpuInstanceById)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7026
 *     global __nvmlDeviceGetGpuInstanceById
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstanceById == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceById is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7029
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceById is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstance_t*) noexcept nogil>__nvmlDeviceGetGpuInstanceById)(             # <<<<<<<<<<<<<<
 *         device, id, gpuInstance)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstance_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceById)(__pyx_v_device, __pyx_v_id, __pyx_v_gpuInstance);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7023
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGpuInstanceById(nvmlDevice_t device, unsigned int id, nvmlGpuInstance_t* gpuInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGpuInstanceById
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetGpuInstanceById", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7033
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceGetInfo(nvmlGpuInstance_t gpuInstance, nvmlGpuInstanceInfo_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceGetInfo
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceGetInfo(nvmlGpuInstance_t __pyx_v_gpuInstance, nvmlGpuInstanceInfo_t *__pyx_v_info) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGpuInstanceGetInfo", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7035
 * cdef nvmlReturn_t _nvmlGpuInstanceGetInfo(nvmlGpuInstance_t gpuInstance, nvmlGpuInstanceInfo_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGpuInstanceGetInfo
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGpuInstanceGetInfo == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7035, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7036
 *     global __nvmlGpuInstanceGetInfo
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetInfo is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetInfo == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7037
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlGpuInstanceInfo_t*) noexcept nogil>__nvmlGpuInstanceGetInfo)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7038
 *     if __nvmlGpuInstanceGetInfo == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetInfo is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlGpuInstanceInfo_t*) noexcept nogil>__nvmlGpuInstanceGetInfo)(
 *         gpuInstance, info)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7038, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGpuInstanceGetInfo};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7038, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7038, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7037
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlGpuInstanceInfo_t*) noexcept nogil>__nvmlGpuInstanceGetInfo)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7036
 *     global __nvmlGpuInstanceGetInfo
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetInfo is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7039
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlGpuInstanceInfo_t*) noexcept nogil>__nvmlGpuInstanceGetInfo)(             # <<<<<<<<<<<<<<
 *         gpuInstance, info)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlGpuInstance_t, nvmlGpuInstanceInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetInfo)(__pyx_v_gpuInstance, __pyx_v_info);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7033
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceGetInfo(nvmlGpuInstance_t gpuInstance, nvmlGpuInstanceInfo_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceGetInfo
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGpuInstanceGetInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7043
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceGetComputeInstanceProfileInfoV(nvmlGpuInstance_t gpuInstance, unsigned int profile, unsigned int engProfile, nvmlComputeInstanceProfileInfo_v2_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceGetComputeInstanceProfileInfoV
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceGetComputeInstanceProfileInfoV(nvmlGpuInstance_t __pyx_v_gpuInstance, unsigned int __pyx_v_profile, unsigned int __pyx_v_engProfile, nvmlComputeInstanceProfileInfo_v2_t *__pyx_v_info) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGpuInstanceGetComputeInstanceProfileInfoV", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7045
 * cdef nvmlReturn_t _nvmlGpuInstanceGetComputeInstanceProfileInfoV(nvmlGpuInstance_t gpuInstance, unsigned int profile, unsigned int engProfile, nvmlComputeInstanceProfileInfo_v2_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGpuInstanceGetComputeInstanceProfileInfoV
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGpuInstanceGetComputeInstanceProfileInfoV == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7045, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7046
 *     global __nvmlGpuInstanceGetComputeInstanceProfileInfoV
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetComputeInstanceProfileInfoV == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstanceProfileInfoV is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstanceProfileInfoV == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7047
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetComputeInstanceProfileInfoV == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstanceProfileInfoV is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, unsigned int, nvmlComputeInstanceProfileInfo_v2_t*) noexcept nogil>__nvmlGpuInstanceGetComputeInstanceProfileInfoV)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7048
 *     if __nvmlGpuInstanceGetComputeInstanceProfileInfoV == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstanceProfileInfoV is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, unsigned int, nvmlComputeInstanceProfileInfo_v2_t*) noexcept nogil>__nvmlGpuInstanceGetComputeInstanceProfileInfoV)(
 *         gpuInstance, profile, engProfile, info)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7048, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGpuInstanceGetCompu};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7048, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7048, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7047
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetComputeInstanceProfileInfoV == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstanceProfileInfoV is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, unsigned int, nvmlComputeInstanceProfileInfo_v2_t*) noexcept nogil>__nvmlGpuInstanceGetComputeInstanceProfileInfoV)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7046
 *     global __nvmlGpuInstanceGetComputeInstanceProfileInfoV
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetComputeInstanceProfileInfoV == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstanceProfileInfoV is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7049
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstanceProfileInfoV is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, unsigned int, nvmlComputeInstanceProfileInfo_v2_t*) noexcept nogil>__nvmlGpuInstanceGetComputeInstanceProfileInfoV)(             # <<<<<<<<<<<<<<
 *         gpuInstance, profile, engProfile, info)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, unsigned int, nvmlComputeInstanceProfileInfo_v2_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstanceProfileInfoV)(__pyx_v_gpuInstance, __pyx_v_profile, __pyx_v_engProfile, __pyx_v_info);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7043
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceGetComputeInstanceProfileInfoV(nvmlGpuInstance_t gpuInstance, unsigned int profile, unsigned int engProfile, nvmlComputeInstanceProfileInfo_v2_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceGetComputeInstanceProfileInfoV
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGpuInstanceGetComputeInstanceProfileInfoV", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7053
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceGetComputeInstanceRemainingCapacity(nvmlGpuInstance_t gpuInstance, unsigned int profileId, unsigned int* count) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceGetComputeInstanceRemainingCapacity
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceGetComputeInstanceRemainingCapacity(nvmlGpuInstance_t __pyx_v_gpuInstance, unsigned int __pyx_v_profileId, unsigned int *__pyx_v_count) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGpuInstanceGetComputeInstanceRemainingCapacity", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7055
 * cdef nvmlReturn_t _nvmlGpuInstanceGetComputeInstanceRemainingCapacity(nvmlGpuInstance_t gpuInstance, unsigned int profileId, unsigned int* count) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGpuInstanceGetComputeInstanceRemainingCapacity
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGpuInstanceGetComputeInstanceRemainingCapacity == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7055, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7056
 *     global __nvmlGpuInstanceGetComputeInstanceRemainingCapacity
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetComputeInstanceRemainingCapacity == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstanceRemainingCapacity is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstanceRemainingCapacity == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7057
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetComputeInstanceRemainingCapacity == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstanceRemainingCapacity is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, unsigned int*) noexcept nogil>__nvmlGpuInstanceGetComputeInstanceRemainingCapacity)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7058
 *     if __nvmlGpuInstanceGetComputeInstanceRemainingCapacity == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstanceRemainingCapacity is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, unsigned int*) noexcept nogil>__nvmlGpuInstanceGetComputeInstanceRemainingCapacity)(
 *         gpuInstance, profileId, count)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7058, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGpuInstanceGetCompu_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7058, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7058, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7057
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetComputeInstanceRemainingCapacity == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstanceRemainingCapacity is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, unsigned int*) noexcept nogil>__nvmlGpuInstanceGetComputeInstanceRemainingCapacity)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7056
 *     global __nvmlGpuInstanceGetComputeInstanceRemainingCapacity
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetComputeInstanceRemainingCapacity == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstanceRemainingCapacity is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7059
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstanceRemainingCapacity is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, unsigned int*) noexcept nogil>__nvmlGpuInstanceGetComputeInstanceRemainingCapacity)(             # <<<<<<<<<<<<<<
 *         gpuInstance, profileId, count)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstanceRemainingCapacity)(__pyx_v_gpuInstance, __pyx_v_profileId, __pyx_v_count);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7053
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceGetComputeInstanceRemainingCapacity(nvmlGpuInstance_t gpuInstance, unsigned int profileId, unsigned int* count) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceGetComputeInstanceRemainingCapacity
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGpuInstanceGetComputeInstanceRemainingCapacity", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7063
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceGetComputeInstancePossiblePlacements(nvmlGpuInstance_t gpuInstance, unsigned int profileId, nvmlComputeInstancePlacement_t* placements, unsigned int* count) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceGetComputeInstancePossiblePlacements
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceGetComputeInstancePossiblePlacements(nvmlGpuInstance_t __pyx_v_gpuInstance, unsigned int __pyx_v_profileId, nvmlComputeInstancePlacement_t *__pyx_v_placements, unsigned int *__pyx_v_count) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGpuInstanceGetComputeInstancePossiblePlacements", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7065
 * cdef nvmlReturn_t _nvmlGpuInstanceGetComputeInstancePossiblePlacements(nvmlGpuInstance_t gpuInstance, unsigned int profileId, nvmlComputeInstancePlacement_t* placements, unsigned int* count) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGpuInstanceGetComputeInstancePossiblePlacements
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGpuInstanceGetComputeInstancePossiblePlacements == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7065, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7066
 *     global __nvmlGpuInstanceGetComputeInstancePossiblePlacements
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetComputeInstancePossiblePlacements == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstancePossiblePlacements is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstancePossiblePlacements == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7067
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetComputeInstancePossiblePlacements == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstancePossiblePlacements is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, nvmlComputeInstancePlacement_t*, unsigned int*) noexcept nogil>__nvmlGpuInstanceGetComputeInstancePossiblePlacements)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7068
 *     if __nvmlGpuInstanceGetComputeInstancePossiblePlacements == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstancePossiblePlacements is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, nvmlComputeInstancePlacement_t*, unsigned int*) noexcept nogil>__nvmlGpuInstanceGetComputeInstancePossiblePlacements)(
 *         gpuInstance, profileId, placements, count)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7068, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGpuInstanceGetCompu_3};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7068, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7068, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7067
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetComputeInstancePossiblePlacements == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstancePossiblePlacements is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, nvmlComputeInstancePlacement_t*, unsigned int*) noexcept nogil>__nvmlGpuInstanceGetComputeInstancePossiblePlacements)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7066
 *     global __nvmlGpuInstanceGetComputeInstancePossiblePlacements
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetComputeInstancePossiblePlacements == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstancePossiblePlacements is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7069
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstancePossiblePlacements is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, nvmlComputeInstancePlacement_t*, unsigned int*) noexcept nogil>__nvmlGpuInstanceGetComputeInstancePossiblePlacements)(             # <<<<<<<<<<<<<<
 *         gpuInstance, profileId, placements, count)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, nvmlComputeInstancePlacement_t *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstancePossiblePlacements)(__pyx_v_gpuInstance, __pyx_v_profileId, __pyx_v_placements, __pyx_v_count);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7063
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceGetComputeInstancePossiblePlacements(nvmlGpuInstance_t gpuInstance, unsigned int profileId, nvmlComputeInstancePlacement_t* placements, unsigned int* count) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceGetComputeInstancePossiblePlacements
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGpuInstanceGetComputeInstancePossiblePlacements", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7073
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceCreateComputeInstance(nvmlGpuInstance_t gpuInstance, unsigned int profileId, nvmlComputeInstance_t* computeInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceCreateComputeInstance
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceCreateComputeInstance(nvmlGpuInstance_t __pyx_v_gpuInstance, unsigned int __pyx_v_profileId, nvmlComputeInstance_t *__pyx_v_computeInstance) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGpuInstanceCreateComputeInstance", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7075
 * cdef nvmlReturn_t _nvmlGpuInstanceCreateComputeInstance(nvmlGpuInstance_t gpuInstance, unsigned int profileId, nvmlComputeInstance_t* computeInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGpuInstanceCreateComputeInstance
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGpuInstanceCreateComputeInstance == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7075, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7076
 *     global __nvmlGpuInstanceCreateComputeInstance
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceCreateComputeInstance == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceCreateComputeInstance is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceCreateComputeInstance == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7077
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceCreateComputeInstance == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceCreateComputeInstance is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, nvmlComputeInstance_t*) noexcept nogil>__nvmlGpuInstanceCreateComputeInstance)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7078
 *     if __nvmlGpuInstanceCreateComputeInstance == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceCreateComputeInstance is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, nvmlComputeInstance_t*) noexcept nogil>__nvmlGpuInstanceCreateComputeInstance)(
 *         gpuInstance, profileId, computeInstance)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7078, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGpuInstanceCreateCo};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7078, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7078, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7077
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceCreateComputeInstance == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceCreateComputeInstance is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, nvmlComputeInstance_t*) noexcept nogil>__nvmlGpuInstanceCreateComputeInstance)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7076
 *     global __nvmlGpuInstanceCreateComputeInstance
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceCreateComputeInstance == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceCreateComputeInstance is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7079
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceCreateComputeInstance is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, nvmlComputeInstance_t*) noexcept nogil>__nvmlGpuInstanceCreateComputeInstance)(             # <<<<<<<<<<<<<<
 *         gpuInstance, profileId, computeInstance)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, nvmlComputeInstance_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceCreateComputeInstance)(__pyx_v_gpuInstance, __pyx_v_profileId, __pyx_v_computeInstance);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7073
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceCreateComputeInstance(nvmlGpuInstance_t gpuInstance, unsigned int profileId, nvmlComputeInstance_t* computeInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceCreateComputeInstance
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGpuInstanceCreateComputeInstance", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7083
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceCreateComputeInstanceWithPlacement(nvmlGpuInstance_t gpuInstance, unsigned int profileId, const nvmlComputeInstancePlacement_t* placement, nvmlComputeInstance_t* computeInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceCreateComputeInstanceWithPlacement
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceCreateComputeInstanceWithPlacement(nvmlGpuInstance_t __pyx_v_gpuInstance, unsigned int __pyx_v_profileId, nvmlComputeInstancePlacement_t const *__pyx_v_placement, nvmlComputeInstance_t *__pyx_v_computeInstance) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGpuInstanceCreateComputeInstanceWithPlacement", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7085
 * cdef nvmlReturn_t _nvmlGpuInstanceCreateComputeInstanceWithPlacement(nvmlGpuInstance_t gpuInstance, unsigned int profileId, const nvmlComputeInstancePlacement_t* placement, nvmlComputeInstance_t* computeInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGpuInstanceCreateComputeInstanceWithPlacement
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGpuInstanceCreateComputeInstanceWithPlacement == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7085, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7086
 *     global __nvmlGpuInstanceCreateComputeInstanceWithPlacement
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceCreateComputeInstanceWithPlacement == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceCreateComputeInstanceWithPlacement is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceCreateComputeInstanceWithPlacement == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7087
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceCreateComputeInstanceWithPlacement == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceCreateComputeInstanceWithPlacement is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, const nvmlComputeInstancePlacement_t*, nvmlComputeInstance_t*) noexcept nogil>__nvmlGpuInstanceCreateComputeInstanceWithPlacement)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7088
 *     if __nvmlGpuInstanceCreateComputeInstanceWithPlacement == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceCreateComputeInstanceWithPlacement is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, const nvmlComputeInstancePlacement_t*, nvmlComputeInstance_t*) noexcept nogil>__nvmlGpuInstanceCreateComputeInstanceWithPlacement)(
 *         gpuInstance, profileId, placement, computeInstance)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7088, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGpuInstanceCreateCo_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7088, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7088, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7087
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceCreateComputeInstanceWithPlacement == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceCreateComputeInstanceWithPlacement is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, const nvmlComputeInstancePlacement_t*, nvmlComputeInstance_t*) noexcept nogil>__nvmlGpuInstanceCreateComputeInstanceWithPlacement)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7086
 *     global __nvmlGpuInstanceCreateComputeInstanceWithPlacement
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceCreateComputeInstanceWithPlacement == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceCreateComputeInstanceWithPlacement is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7089
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceCreateComputeInstanceWithPlacement is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, const nvmlComputeInstancePlacement_t*, nvmlComputeInstance_t*) noexcept nogil>__nvmlGpuInstanceCreateComputeInstanceWithPlacement)(             # <<<<<<<<<<<<<<
 *         gpuInstance, profileId, placement, computeInstance)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, nvmlComputeInstancePlacement_t const *, nvmlComputeInstance_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceCreateComputeInstanceWithPlacement)(__pyx_v_gpuInstance, __pyx_v_profileId, __pyx_v_placement, __pyx_v_computeInstance);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7083
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceCreateComputeInstanceWithPlacement(nvmlGpuInstance_t gpuInstance, unsigned int profileId, const nvmlComputeInstancePlacement_t* placement, nvmlComputeInstance_t* computeInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceCreateComputeInstanceWithPlacement
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGpuInstanceCreateComputeInstanceWithPlacement", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7093
 * 
 * 
 * cdef nvmlReturn_t _nvmlComputeInstanceDestroy(nvmlComputeInstance_t computeInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlComputeInstanceDestroy
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlComputeInstanceDestroy(nvmlComputeInstance_t __pyx_v_computeInstance) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlComputeInstanceDestroy", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7095
 * cdef nvmlReturn_t _nvmlComputeInstanceDestroy(nvmlComputeInstance_t computeInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlComputeInstanceDestroy
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlComputeInstanceDestroy == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7095, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7096
 *     global __nvmlComputeInstanceDestroy
 *     _check_or_init_nvml()
 *     if __nvmlComputeInstanceDestroy == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlComputeInstanceDestroy is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlComputeInstanceDestroy == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7097
 *     _check_or_init_nvml()
 *     if __nvmlComputeInstanceDestroy == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlComputeInstanceDestroy is not found")
 *     return (<nvmlReturn_t (*)(nvmlComputeInstance_t) noexcept nogil>__nvmlComputeInstanceDestroy)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7098
 *     if __nvmlComputeInstanceDestroy == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlComputeInstanceDestroy is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlComputeInstance_t) noexcept nogil>__nvmlComputeInstanceDestroy)(
 *         computeInstance)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7098, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlComputeInstanceDest};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7098, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7098, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7097
 *     _check_or_init_nvml()
 *     if __nvmlComputeInstanceDestroy == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlComputeInstanceDestroy is not found")
 *     return (<nvmlReturn_t (*)(nvmlComputeInstance_t) noexcept nogil>__nvmlComputeInstanceDestroy)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7096
 *     global __nvmlComputeInstanceDestroy
 *     _check_or_init_nvml()
 *     if __nvmlComputeInstanceDestroy == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlComputeInstanceDestroy is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7099
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlComputeInstanceDestroy is not found")
 *     return (<nvmlReturn_t (*)(nvmlComputeInstance_t) noexcept nogil>__nvmlComputeInstanceDestroy)(             # <<<<<<<<<<<<<<
 *         computeInstance)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlComputeInstance_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlComputeInstanceDestroy)(__pyx_v_computeInstance);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7093
 * 
 * 
 * cdef nvmlReturn_t _nvmlComputeInstanceDestroy(nvmlComputeInstance_t computeInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlComputeInstanceDestroy
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlComputeInstanceDestroy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7103
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceGetComputeInstances(nvmlGpuInstance_t gpuInstance, unsigned int profileId, nvmlComputeInstance_t* computeInstances, unsigned int* count) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceGetComputeInstances
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceGetComputeInstances(nvmlGpuInstance_t __pyx_v_gpuInstance, unsigned int __pyx_v_profileId, nvmlComputeInstance_t *__pyx_v_computeInstances, unsigned int *__pyx_v_count) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGpuInstanceGetComputeInstances", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7105
 * cdef nvmlReturn_t _nvmlGpuInstanceGetComputeInstances(nvmlGpuInstance_t gpuInstance, unsigned int profileId, nvmlComputeInstance_t* computeInstances, unsigned int* count) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGpuInstanceGetComputeInstances
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGpuInstanceGetComputeInstances == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7105, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7106
 *     global __nvmlGpuInstanceGetComputeInstances
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetComputeInstances == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstances is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstances == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7107
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetComputeInstances == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstances is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, nvmlComputeInstance_t*, unsigned int*) noexcept nogil>__nvmlGpuInstanceGetComputeInstances)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7108
 *     if __nvmlGpuInstanceGetComputeInstances == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstances is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, nvmlComputeInstance_t*, unsigned int*) noexcept nogil>__nvmlGpuInstanceGetComputeInstances)(
 *         gpuInstance, profileId, computeInstances, count)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7108, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGpuInstanceGetCompu_4};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7108, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7108, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7107
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetComputeInstances == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstances is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, nvmlComputeInstance_t*, unsigned int*) noexcept nogil>__nvmlGpuInstanceGetComputeInstances)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7106
 *     global __nvmlGpuInstanceGetComputeInstances
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetComputeInstances == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstances is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7109
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstances is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, nvmlComputeInstance_t*, unsigned int*) noexcept nogil>__nvmlGpuInstanceGetComputeInstances)(             # <<<<<<<<<<<<<<
 *         gpuInstance, profileId, computeInstances, count)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, nvmlComputeInstance_t *, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstances)(__pyx_v_gpuInstance, __pyx_v_profileId, __pyx_v_computeInstances, __pyx_v_count);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7103
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceGetComputeInstances(nvmlGpuInstance_t gpuInstance, unsigned int profileId, nvmlComputeInstance_t* computeInstances, unsigned int* count) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceGetComputeInstances
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGpuInstanceGetComputeInstances", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7113
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceGetComputeInstanceById(nvmlGpuInstance_t gpuInstance, unsigned int id, nvmlComputeInstance_t* computeInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceGetComputeInstanceById
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceGetComputeInstanceById(nvmlGpuInstance_t __pyx_v_gpuInstance, unsigned int __pyx_v_id, nvmlComputeInstance_t *__pyx_v_computeInstance) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGpuInstanceGetComputeInstanceById", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7115
 * cdef nvmlReturn_t _nvmlGpuInstanceGetComputeInstanceById(nvmlGpuInstance_t gpuInstance, unsigned int id, nvmlComputeInstance_t* computeInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGpuInstanceGetComputeInstanceById
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGpuInstanceGetComputeInstanceById == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7115, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7116
 *     global __nvmlGpuInstanceGetComputeInstanceById
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetComputeInstanceById == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstanceById is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstanceById == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7117
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetComputeInstanceById == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstanceById is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, nvmlComputeInstance_t*) noexcept nogil>__nvmlGpuInstanceGetComputeInstanceById)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7118
 *     if __nvmlGpuInstanceGetComputeInstanceById == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstanceById is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, nvmlComputeInstance_t*) noexcept nogil>__nvmlGpuInstanceGetComputeInstanceById)(
 *         gpuInstance, id, computeInstance)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7118, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGpuInstanceGetCompu_5};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7118, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7118, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7117
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetComputeInstanceById == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstanceById is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, nvmlComputeInstance_t*) noexcept nogil>__nvmlGpuInstanceGetComputeInstanceById)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7116
 *     global __nvmlGpuInstanceGetComputeInstanceById
 *     _check_or_init_nvml()
 *     if __nvmlGpuInstanceGetComputeInstanceById == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstanceById is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7119
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpuInstanceGetComputeInstanceById is not found")
 *     return (<nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, nvmlComputeInstance_t*) noexcept nogil>__nvmlGpuInstanceGetComputeInstanceById)(             # <<<<<<<<<<<<<<
 *         gpuInstance, id, computeInstance)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlGpuInstance_t, unsigned int, nvmlComputeInstance_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstanceById)(__pyx_v_gpuInstance, __pyx_v_id, __pyx_v_computeInstance);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7113
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpuInstanceGetComputeInstanceById(nvmlGpuInstance_t gpuInstance, unsigned int id, nvmlComputeInstance_t* computeInstance) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpuInstanceGetComputeInstanceById
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGpuInstanceGetComputeInstanceById", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7123
 * 
 * 
 * cdef nvmlReturn_t _nvmlComputeInstanceGetInfo_v2(nvmlComputeInstance_t computeInstance, nvmlComputeInstanceInfo_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlComputeInstanceGetInfo_v2
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlComputeInstanceGetInfo_v2(nvmlComputeInstance_t __pyx_v_computeInstance, nvmlComputeInstanceInfo_t *__pyx_v_info) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlComputeInstanceGetInfo_v2", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7125
 * cdef nvmlReturn_t _nvmlComputeInstanceGetInfo_v2(nvmlComputeInstance_t computeInstance, nvmlComputeInstanceInfo_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlComputeInstanceGetInfo_v2
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlComputeInstanceGetInfo_v2 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7125, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7126
 *     global __nvmlComputeInstanceGetInfo_v2
 *     _check_or_init_nvml()
 *     if __nvmlComputeInstanceGetInfo_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlComputeInstanceGetInfo_v2 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlComputeInstanceGetInfo_v2 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7127
 *     _check_or_init_nvml()
 *     if __nvmlComputeInstanceGetInfo_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlComputeInstanceGetInfo_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlComputeInstance_t, nvmlComputeInstanceInfo_t*) noexcept nogil>__nvmlComputeInstanceGetInfo_v2)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7128
 *     if __nvmlComputeInstanceGetInfo_v2 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlComputeInstanceGetInfo_v2 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlComputeInstance_t, nvmlComputeInstanceInfo_t*) noexcept nogil>__nvmlComputeInstanceGetInfo_v2)(
 *         computeInstance, info)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7128, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlComputeInstanceGetI};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7128, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7128, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7127
 *     _check_or_init_nvml()
 *     if __nvmlComputeInstanceGetInfo_v2 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlComputeInstanceGetInfo_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlComputeInstance_t, nvmlComputeInstanceInfo_t*) noexcept nogil>__nvmlComputeInstanceGetInfo_v2)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7126
 *     global __nvmlComputeInstanceGetInfo_v2
 *     _check_or_init_nvml()
 *     if __nvmlComputeInstanceGetInfo_v2 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlComputeInstanceGetInfo_v2 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7129
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlComputeInstanceGetInfo_v2 is not found")
 *     return (<nvmlReturn_t (*)(nvmlComputeInstance_t, nvmlComputeInstanceInfo_t*) noexcept nogil>__nvmlComputeInstanceGetInfo_v2)(             # <<<<<<<<<<<<<<
 *         computeInstance, info)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlComputeInstance_t, nvmlComputeInstanceInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlComputeInstanceGetInfo_v2)(__pyx_v_computeInstance, __pyx_v_info);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7123
 * 
 * 
 * cdef nvmlReturn_t _nvmlComputeInstanceGetInfo_v2(nvmlComputeInstance_t computeInstance, nvmlComputeInstanceInfo_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlComputeInstanceGetInfo_v2
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlComputeInstanceGetInfo_v2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7133
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceIsMigDeviceHandle(nvmlDevice_t device, unsigned int* isMigDevice) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceIsMigDeviceHandle
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceIsMigDeviceHandle(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_isMigDevice) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceIsMigDeviceHandle", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7135
 * cdef nvmlReturn_t _nvmlDeviceIsMigDeviceHandle(nvmlDevice_t device, unsigned int* isMigDevice) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceIsMigDeviceHandle
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceIsMigDeviceHandle == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7135, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7136
 *     global __nvmlDeviceIsMigDeviceHandle
 *     _check_or_init_nvml()
 *     if __nvmlDeviceIsMigDeviceHandle == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceIsMigDeviceHandle is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceIsMigDeviceHandle == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7137
 *     _check_or_init_nvml()
 *     if __nvmlDeviceIsMigDeviceHandle == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceIsMigDeviceHandle is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceIsMigDeviceHandle)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7138
 *     if __nvmlDeviceIsMigDeviceHandle == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceIsMigDeviceHandle is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceIsMigDeviceHandle)(
 *         device, isMigDevice)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7138, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceIsMigDeviceHa};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7138, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7138, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7137
 *     _check_or_init_nvml()
 *     if __nvmlDeviceIsMigDeviceHandle == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceIsMigDeviceHandle is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceIsMigDeviceHandle)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7136
 *     global __nvmlDeviceIsMigDeviceHandle
 *     _check_or_init_nvml()
 *     if __nvmlDeviceIsMigDeviceHandle == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceIsMigDeviceHandle is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7139
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceIsMigDeviceHandle is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceIsMigDeviceHandle)(             # <<<<<<<<<<<<<<
 *         device, isMigDevice)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceIsMigDeviceHandle)(__pyx_v_device, __pyx_v_isMigDevice);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7133
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceIsMigDeviceHandle(nvmlDevice_t device, unsigned int* isMigDevice) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceIsMigDeviceHandle
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceIsMigDeviceHandle", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7143
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGpuInstanceId(nvmlDevice_t device, unsigned int* id) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGpuInstanceId
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGpuInstanceId(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_id) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetGpuInstanceId", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7145
 * cdef nvmlReturn_t _nvmlDeviceGetGpuInstanceId(nvmlDevice_t device, unsigned int* id) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetGpuInstanceId
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetGpuInstanceId == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7145, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7146
 *     global __nvmlDeviceGetGpuInstanceId
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstanceId == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceId is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceId == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7147
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstanceId == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceId is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetGpuInstanceId)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7148
 *     if __nvmlDeviceGetGpuInstanceId == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceId is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetGpuInstanceId)(
 *         device, id)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7148, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetGpuInstanc_6};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7148, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7148, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7147
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstanceId == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceId is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetGpuInstanceId)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7146
 *     global __nvmlDeviceGetGpuInstanceId
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstanceId == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceId is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7149
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceId is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetGpuInstanceId)(             # <<<<<<<<<<<<<<
 *         device, id)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceId)(__pyx_v_device, __pyx_v_id);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7143
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGpuInstanceId(nvmlDevice_t device, unsigned int* id) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGpuInstanceId
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetGpuInstanceId", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7153
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetComputeInstanceId(nvmlDevice_t device, unsigned int* id) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetComputeInstanceId
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetComputeInstanceId(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_id) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetComputeInstanceId", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7155
 * cdef nvmlReturn_t _nvmlDeviceGetComputeInstanceId(nvmlDevice_t device, unsigned int* id) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetComputeInstanceId
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetComputeInstanceId == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7155, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7156
 *     global __nvmlDeviceGetComputeInstanceId
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetComputeInstanceId == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetComputeInstanceId is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetComputeInstanceId == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7157
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetComputeInstanceId == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetComputeInstanceId is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetComputeInstanceId)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7158
 *     if __nvmlDeviceGetComputeInstanceId == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetComputeInstanceId is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetComputeInstanceId)(
 *         device, id)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7158, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetComputeIns};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7158, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7158, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7157
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetComputeInstanceId == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetComputeInstanceId is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetComputeInstanceId)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7156
 *     global __nvmlDeviceGetComputeInstanceId
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetComputeInstanceId == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetComputeInstanceId is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7159
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetComputeInstanceId is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetComputeInstanceId)(             # <<<<<<<<<<<<<<
 *         device, id)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetComputeInstanceId)(__pyx_v_device, __pyx_v_id);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7153
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetComputeInstanceId(nvmlDevice_t device, unsigned int* id) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetComputeInstanceId
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetComputeInstanceId", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7163
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMaxMigDeviceCount(nvmlDevice_t device, unsigned int* count) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMaxMigDeviceCount
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMaxMigDeviceCount(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_count) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetMaxMigDeviceCount", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7165
 * cdef nvmlReturn_t _nvmlDeviceGetMaxMigDeviceCount(nvmlDevice_t device, unsigned int* count) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetMaxMigDeviceCount
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetMaxMigDeviceCount == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7165, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7166
 *     global __nvmlDeviceGetMaxMigDeviceCount
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMaxMigDeviceCount == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxMigDeviceCount is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxMigDeviceCount == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7167
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMaxMigDeviceCount == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxMigDeviceCount is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMaxMigDeviceCount)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7168
 *     if __nvmlDeviceGetMaxMigDeviceCount == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxMigDeviceCount is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMaxMigDeviceCount)(
 *         device, count)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7168, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetMaxMigDevi};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7168, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7168, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7167
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMaxMigDeviceCount == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxMigDeviceCount is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMaxMigDeviceCount)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7166
 *     global __nvmlDeviceGetMaxMigDeviceCount
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMaxMigDeviceCount == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxMigDeviceCount is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7169
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMaxMigDeviceCount is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlDeviceGetMaxMigDeviceCount)(             # <<<<<<<<<<<<<<
 *         device, count)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxMigDeviceCount)(__pyx_v_device, __pyx_v_count);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7163
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMaxMigDeviceCount(nvmlDevice_t device, unsigned int* count) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMaxMigDeviceCount
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetMaxMigDeviceCount", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7173
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMigDeviceHandleByIndex(nvmlDevice_t device, unsigned int index, nvmlDevice_t* migDevice) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMigDeviceHandleByIndex
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMigDeviceHandleByIndex(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_index, nvmlDevice_t *__pyx_v_migDevice) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetMigDeviceHandleByIndex", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7175
 * cdef nvmlReturn_t _nvmlDeviceGetMigDeviceHandleByIndex(nvmlDevice_t device, unsigned int index, nvmlDevice_t* migDevice) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetMigDeviceHandleByIndex
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetMigDeviceHandleByIndex == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7175, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7176
 *     global __nvmlDeviceGetMigDeviceHandleByIndex
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMigDeviceHandleByIndex == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMigDeviceHandleByIndex is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMigDeviceHandleByIndex == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7177
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMigDeviceHandleByIndex == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMigDeviceHandleByIndex is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetMigDeviceHandleByIndex)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7178
 *     if __nvmlDeviceGetMigDeviceHandleByIndex == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMigDeviceHandleByIndex is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetMigDeviceHandleByIndex)(
 *         device, index, migDevice)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7178, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetMigDeviceH};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7178, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7178, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7177
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMigDeviceHandleByIndex == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetMigDeviceHandleByIndex is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetMigDeviceHandleByIndex)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7176
 *     global __nvmlDeviceGetMigDeviceHandleByIndex
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetMigDeviceHandleByIndex == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMigDeviceHandleByIndex is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7179
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetMigDeviceHandleByIndex is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetMigDeviceHandleByIndex)(             # <<<<<<<<<<<<<<
 *         device, index, migDevice)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlDevice_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMigDeviceHandleByIndex)(__pyx_v_device, __pyx_v_index, __pyx_v_migDevice);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7173
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetMigDeviceHandleByIndex(nvmlDevice_t device, unsigned int index, nvmlDevice_t* migDevice) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetMigDeviceHandleByIndex
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetMigDeviceHandleByIndex", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7183
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetDeviceHandleFromMigDeviceHandle(nvmlDevice_t migDevice, nvmlDevice_t* device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetDeviceHandleFromMigDeviceHandle
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetDeviceHandleFromMigDeviceHandle(nvmlDevice_t __pyx_v_migDevice, nvmlDevice_t *__pyx_v_device) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetDeviceHandleFromMigDeviceHandle", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7185
 * cdef nvmlReturn_t _nvmlDeviceGetDeviceHandleFromMigDeviceHandle(nvmlDevice_t migDevice, nvmlDevice_t* device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetDeviceHandleFromMigDeviceHandle
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetDeviceHandleFromMigDeviceHandle == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7185, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7186
 *     global __nvmlDeviceGetDeviceHandleFromMigDeviceHandle
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDeviceHandleFromMigDeviceHandle == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDeviceHandleFromMigDeviceHandle is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDeviceHandleFromMigDeviceHandle == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7187
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDeviceHandleFromMigDeviceHandle == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetDeviceHandleFromMigDeviceHandle is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetDeviceHandleFromMigDeviceHandle)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7188
 *     if __nvmlDeviceGetDeviceHandleFromMigDeviceHandle == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDeviceHandleFromMigDeviceHandle is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetDeviceHandleFromMigDeviceHandle)(
 *         migDevice, device)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7188, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetDeviceHand};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7188, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7188, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7187
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDeviceHandleFromMigDeviceHandle == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetDeviceHandleFromMigDeviceHandle is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetDeviceHandleFromMigDeviceHandle)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7186
 *     global __nvmlDeviceGetDeviceHandleFromMigDeviceHandle
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetDeviceHandleFromMigDeviceHandle == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDeviceHandleFromMigDeviceHandle is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7189
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetDeviceHandleFromMigDeviceHandle is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevice_t*) noexcept nogil>__nvmlDeviceGetDeviceHandleFromMigDeviceHandle)(             # <<<<<<<<<<<<<<
 *         migDevice, device)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlDevice_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDeviceHandleFromMigDeviceHandle)(__pyx_v_migDevice, __pyx_v_device);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7183
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetDeviceHandleFromMigDeviceHandle(nvmlDevice_t migDevice, nvmlDevice_t* device) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetDeviceHandleFromMigDeviceHandle
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetDeviceHandleFromMigDeviceHandle", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7193
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpmSampleGet(nvmlDevice_t device, nvmlGpmSample_t gpmSample) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpmSampleGet
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpmSampleGet(nvmlDevice_t __pyx_v_device, nvmlGpmSample_t __pyx_v_gpmSample) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGpmSampleGet", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7195
 * cdef nvmlReturn_t _nvmlGpmSampleGet(nvmlDevice_t device, nvmlGpmSample_t gpmSample) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGpmSampleGet
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGpmSampleGet == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7195, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7196
 *     global __nvmlGpmSampleGet
 *     _check_or_init_nvml()
 *     if __nvmlGpmSampleGet == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpmSampleGet is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmSampleGet == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7197
 *     _check_or_init_nvml()
 *     if __nvmlGpmSampleGet == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpmSampleGet is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpmSample_t) noexcept nogil>__nvmlGpmSampleGet)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7198
 *     if __nvmlGpmSampleGet == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpmSampleGet is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpmSample_t) noexcept nogil>__nvmlGpmSampleGet)(
 *         device, gpmSample)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7198, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGpmSampleGet_is_not};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7198, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7198, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7197
 *     _check_or_init_nvml()
 *     if __nvmlGpmSampleGet == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpmSampleGet is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpmSample_t) noexcept nogil>__nvmlGpmSampleGet)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7196
 *     global __nvmlGpmSampleGet
 *     _check_or_init_nvml()
 *     if __nvmlGpmSampleGet == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpmSampleGet is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7199
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpmSampleGet is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpmSample_t) noexcept nogil>__nvmlGpmSampleGet)(             # <<<<<<<<<<<<<<
 *         device, gpmSample)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlGpmSample_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmSampleGet)(__pyx_v_device, __pyx_v_gpmSample);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7193
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpmSampleGet(nvmlDevice_t device, nvmlGpmSample_t gpmSample) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpmSampleGet
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGpmSampleGet", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7203
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpmMigSampleGet(nvmlDevice_t device, unsigned int gpuInstanceId, nvmlGpmSample_t gpmSample) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpmMigSampleGet
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpmMigSampleGet(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_gpuInstanceId, nvmlGpmSample_t __pyx_v_gpmSample) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGpmMigSampleGet", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7205
 * cdef nvmlReturn_t _nvmlGpmMigSampleGet(nvmlDevice_t device, unsigned int gpuInstanceId, nvmlGpmSample_t gpmSample) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGpmMigSampleGet
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGpmMigSampleGet == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7205, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7206
 *     global __nvmlGpmMigSampleGet
 *     _check_or_init_nvml()
 *     if __nvmlGpmMigSampleGet == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpmMigSampleGet is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmMigSampleGet == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7207
 *     _check_or_init_nvml()
 *     if __nvmlGpmMigSampleGet == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpmMigSampleGet is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpmSample_t) noexcept nogil>__nvmlGpmMigSampleGet)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7208
 *     if __nvmlGpmMigSampleGet == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpmMigSampleGet is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpmSample_t) noexcept nogil>__nvmlGpmMigSampleGet)(
 *         device, gpuInstanceId, gpmSample)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7208, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGpmMigSampleGet_is};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7208, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7208, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7207
 *     _check_or_init_nvml()
 *     if __nvmlGpmMigSampleGet == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpmMigSampleGet is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpmSample_t) noexcept nogil>__nvmlGpmMigSampleGet)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7206
 *     global __nvmlGpmMigSampleGet
 *     _check_or_init_nvml()
 *     if __nvmlGpmMigSampleGet == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpmMigSampleGet is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7209
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpmMigSampleGet is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpmSample_t) noexcept nogil>__nvmlGpmMigSampleGet)(             # <<<<<<<<<<<<<<
 *         device, gpuInstanceId, gpmSample)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpmSample_t))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmMigSampleGet)(__pyx_v_device, __pyx_v_gpuInstanceId, __pyx_v_gpmSample);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7203
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpmMigSampleGet(nvmlDevice_t device, unsigned int gpuInstanceId, nvmlGpmSample_t gpmSample) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpmMigSampleGet
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGpmMigSampleGet", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7213
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpmQueryDeviceSupport(nvmlDevice_t device, nvmlGpmSupport_t* gpmSupport) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpmQueryDeviceSupport
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpmQueryDeviceSupport(nvmlDevice_t __pyx_v_device, nvmlGpmSupport_t *__pyx_v_gpmSupport) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGpmQueryDeviceSupport", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7215
 * cdef nvmlReturn_t _nvmlGpmQueryDeviceSupport(nvmlDevice_t device, nvmlGpmSupport_t* gpmSupport) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGpmQueryDeviceSupport
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGpmQueryDeviceSupport == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7215, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7216
 *     global __nvmlGpmQueryDeviceSupport
 *     _check_or_init_nvml()
 *     if __nvmlGpmQueryDeviceSupport == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpmQueryDeviceSupport is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmQueryDeviceSupport == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7217
 *     _check_or_init_nvml()
 *     if __nvmlGpmQueryDeviceSupport == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpmQueryDeviceSupport is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpmSupport_t*) noexcept nogil>__nvmlGpmQueryDeviceSupport)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7218
 *     if __nvmlGpmQueryDeviceSupport == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpmQueryDeviceSupport is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpmSupport_t*) noexcept nogil>__nvmlGpmQueryDeviceSupport)(
 *         device, gpmSupport)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7218, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGpmQueryDeviceSuppo};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7218, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7218, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7217
 *     _check_or_init_nvml()
 *     if __nvmlGpmQueryDeviceSupport == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpmQueryDeviceSupport is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpmSupport_t*) noexcept nogil>__nvmlGpmQueryDeviceSupport)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7216
 *     global __nvmlGpmQueryDeviceSupport
 *     _check_or_init_nvml()
 *     if __nvmlGpmQueryDeviceSupport == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpmQueryDeviceSupport is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7219
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpmQueryDeviceSupport is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlGpmSupport_t*) noexcept nogil>__nvmlGpmQueryDeviceSupport)(             # <<<<<<<<<<<<<<
 *         device, gpmSupport)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlGpmSupport_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmQueryDeviceSupport)(__pyx_v_device, __pyx_v_gpmSupport);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7213
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpmQueryDeviceSupport(nvmlDevice_t device, nvmlGpmSupport_t* gpmSupport) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpmQueryDeviceSupport
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGpmQueryDeviceSupport", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7223
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpmQueryIfStreamingEnabled(nvmlDevice_t device, unsigned int* state) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpmQueryIfStreamingEnabled
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpmQueryIfStreamingEnabled(nvmlDevice_t __pyx_v_device, unsigned int *__pyx_v_state) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGpmQueryIfStreamingEnabled", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7225
 * cdef nvmlReturn_t _nvmlGpmQueryIfStreamingEnabled(nvmlDevice_t device, unsigned int* state) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGpmQueryIfStreamingEnabled
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGpmQueryIfStreamingEnabled == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7225, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7226
 *     global __nvmlGpmQueryIfStreamingEnabled
 *     _check_or_init_nvml()
 *     if __nvmlGpmQueryIfStreamingEnabled == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpmQueryIfStreamingEnabled is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmQueryIfStreamingEnabled == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7227
 *     _check_or_init_nvml()
 *     if __nvmlGpmQueryIfStreamingEnabled == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpmQueryIfStreamingEnabled is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlGpmQueryIfStreamingEnabled)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7228
 *     if __nvmlGpmQueryIfStreamingEnabled == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpmQueryIfStreamingEnabled is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlGpmQueryIfStreamingEnabled)(
 *         device, state)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7228, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGpmQueryIfStreaming};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7228, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7228, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7227
 *     _check_or_init_nvml()
 *     if __nvmlGpmQueryIfStreamingEnabled == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpmQueryIfStreamingEnabled is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlGpmQueryIfStreamingEnabled)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7226
 *     global __nvmlGpmQueryIfStreamingEnabled
 *     _check_or_init_nvml()
 *     if __nvmlGpmQueryIfStreamingEnabled == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpmQueryIfStreamingEnabled is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7229
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpmQueryIfStreamingEnabled is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int*) noexcept nogil>__nvmlGpmQueryIfStreamingEnabled)(             # <<<<<<<<<<<<<<
 *         device, state)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmQueryIfStreamingEnabled)(__pyx_v_device, __pyx_v_state);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7223
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpmQueryIfStreamingEnabled(nvmlDevice_t device, unsigned int* state) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpmQueryIfStreamingEnabled
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGpmQueryIfStreamingEnabled", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7233
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpmSetStreamingEnabled(nvmlDevice_t device, unsigned int state) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpmSetStreamingEnabled
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpmSetStreamingEnabled(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_state) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlGpmSetStreamingEnabled", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7235
 * cdef nvmlReturn_t _nvmlGpmSetStreamingEnabled(nvmlDevice_t device, unsigned int state) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlGpmSetStreamingEnabled
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlGpmSetStreamingEnabled == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7235, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7236
 *     global __nvmlGpmSetStreamingEnabled
 *     _check_or_init_nvml()
 *     if __nvmlGpmSetStreamingEnabled == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpmSetStreamingEnabled is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmSetStreamingEnabled == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7237
 *     _check_or_init_nvml()
 *     if __nvmlGpmSetStreamingEnabled == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpmSetStreamingEnabled is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int) noexcept nogil>__nvmlGpmSetStreamingEnabled)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7238
 *     if __nvmlGpmSetStreamingEnabled == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpmSetStreamingEnabled is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int) noexcept nogil>__nvmlGpmSetStreamingEnabled)(
 *         device, state)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7238, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlGpmSetStreamingEnab};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7238, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7238, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7237
 *     _check_or_init_nvml()
 *     if __nvmlGpmSetStreamingEnabled == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlGpmSetStreamingEnabled is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int) noexcept nogil>__nvmlGpmSetStreamingEnabled)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7236
 *     global __nvmlGpmSetStreamingEnabled
 *     _check_or_init_nvml()
 *     if __nvmlGpmSetStreamingEnabled == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpmSetStreamingEnabled is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7239
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlGpmSetStreamingEnabled is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int) noexcept nogil>__nvmlGpmSetStreamingEnabled)(             # <<<<<<<<<<<<<<
 *         device, state)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmSetStreamingEnabled)(__pyx_v_device, __pyx_v_state);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7233
 * 
 * 
 * cdef nvmlReturn_t _nvmlGpmSetStreamingEnabled(nvmlDevice_t device, unsigned int state) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlGpmSetStreamingEnabled
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlGpmSetStreamingEnabled", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7243
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetCapabilities(nvmlDevice_t device, nvmlDeviceCapabilities_t* caps) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetCapabilities
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetCapabilities(nvmlDevice_t __pyx_v_device, nvmlDeviceCapabilities_t *__pyx_v_caps) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetCapabilities", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7245
 * cdef nvmlReturn_t _nvmlDeviceGetCapabilities(nvmlDevice_t device, nvmlDeviceCapabilities_t* caps) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetCapabilities
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetCapabilities == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7245, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7246
 *     global __nvmlDeviceGetCapabilities
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCapabilities == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCapabilities is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCapabilities == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7247
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCapabilities == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetCapabilities is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceCapabilities_t*) noexcept nogil>__nvmlDeviceGetCapabilities)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7248
 *     if __nvmlDeviceGetCapabilities == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCapabilities is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceCapabilities_t*) noexcept nogil>__nvmlDeviceGetCapabilities)(
 *         device, caps)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7248, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetCapabiliti};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7248, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7248, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7247
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCapabilities == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetCapabilities is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceCapabilities_t*) noexcept nogil>__nvmlDeviceGetCapabilities)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7246
 *     global __nvmlDeviceGetCapabilities
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetCapabilities == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCapabilities is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7249
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetCapabilities is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceCapabilities_t*) noexcept nogil>__nvmlDeviceGetCapabilities)(             # <<<<<<<<<<<<<<
 *         device, caps)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceCapabilities_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCapabilities)(__pyx_v_device, __pyx_v_caps);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7243
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetCapabilities(nvmlDevice_t device, nvmlDeviceCapabilities_t* caps) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetCapabilities
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetCapabilities", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7253
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceWorkloadPowerProfileClearRequestedProfiles(nvmlDevice_t device, nvmlWorkloadPowerProfileRequestedProfiles_t* requestedProfiles) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceWorkloadPowerProfileClearRequestedProfiles(nvmlDevice_t __pyx_v_device, nvmlWorkloadPowerProfileRequestedProfiles_t *__pyx_v_requestedProfiles) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceWorkloadPowerProfileClearRequestedProfiles", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7255
 * cdef nvmlReturn_t _nvmlDeviceWorkloadPowerProfileClearRequestedProfiles(nvmlDevice_t device, nvmlWorkloadPowerProfileRequestedProfiles_t* requestedProfiles) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7255, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7256
 *     global __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles
 *     _check_or_init_nvml()
 *     if __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceWorkloadPowerProfileClearRequestedProfiles is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceWorkloadPowerProfileClearRequestedProfiles == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7257
 *     _check_or_init_nvml()
 *     if __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceWorkloadPowerProfileClearRequestedProfiles is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlWorkloadPowerProfileRequestedProfiles_t*) noexcept nogil>__nvmlDeviceWorkloadPowerProfileClearRequestedProfiles)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7258
 *     if __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceWorkloadPowerProfileClearRequestedProfiles is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlWorkloadPowerProfileRequestedProfiles_t*) noexcept nogil>__nvmlDeviceWorkloadPowerProfileClearRequestedProfiles)(
 *         device, requestedProfiles)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7258, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceWorkloadPower};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7258, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7258, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7257
 *     _check_or_init_nvml()
 *     if __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceWorkloadPowerProfileClearRequestedProfiles is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlWorkloadPowerProfileRequestedProfiles_t*) noexcept nogil>__nvmlDeviceWorkloadPowerProfileClearRequestedProfiles)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7256
 *     global __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles
 *     _check_or_init_nvml()
 *     if __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceWorkloadPowerProfileClearRequestedProfiles is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7259
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceWorkloadPowerProfileClearRequestedProfiles is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlWorkloadPowerProfileRequestedProfiles_t*) noexcept nogil>__nvmlDeviceWorkloadPowerProfileClearRequestedProfiles)(             # <<<<<<<<<<<<<<
 *         device, requestedProfiles)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlWorkloadPowerProfileRequestedProfiles_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceWorkloadPowerProfileClearRequestedProfiles)(__pyx_v_device, __pyx_v_requestedProfiles);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7253
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceWorkloadPowerProfileClearRequestedProfiles(nvmlDevice_t device, nvmlWorkloadPowerProfileRequestedProfiles_t* requestedProfiles) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceWorkloadPowerProfileClearRequestedProfiles", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7263
 * 
 * 
 * cdef nvmlReturn_t _nvmlDevicePowerSmoothingActivatePresetProfile(nvmlDevice_t device, nvmlPowerSmoothingProfile_t* profile) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDevicePowerSmoothingActivatePresetProfile
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDevicePowerSmoothingActivatePresetProfile(nvmlDevice_t __pyx_v_device, nvmlPowerSmoothingProfile_t *__pyx_v_profile) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDevicePowerSmoothingActivatePresetProfile", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7265
 * cdef nvmlReturn_t _nvmlDevicePowerSmoothingActivatePresetProfile(nvmlDevice_t device, nvmlPowerSmoothingProfile_t* profile) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDevicePowerSmoothingActivatePresetProfile
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDevicePowerSmoothingActivatePresetProfile == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7265, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7266
 *     global __nvmlDevicePowerSmoothingActivatePresetProfile
 *     _check_or_init_nvml()
 *     if __nvmlDevicePowerSmoothingActivatePresetProfile == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDevicePowerSmoothingActivatePresetProfile is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDevicePowerSmoothingActivatePresetProfile == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7267
 *     _check_or_init_nvml()
 *     if __nvmlDevicePowerSmoothingActivatePresetProfile == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDevicePowerSmoothingActivatePresetProfile is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerSmoothingProfile_t*) noexcept nogil>__nvmlDevicePowerSmoothingActivatePresetProfile)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7268
 *     if __nvmlDevicePowerSmoothingActivatePresetProfile == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDevicePowerSmoothingActivatePresetProfile is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerSmoothingProfile_t*) noexcept nogil>__nvmlDevicePowerSmoothingActivatePresetProfile)(
 *         device, profile)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7268, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDevicePowerSmoothin};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7268, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7268, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7267
 *     _check_or_init_nvml()
 *     if __nvmlDevicePowerSmoothingActivatePresetProfile == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDevicePowerSmoothingActivatePresetProfile is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerSmoothingProfile_t*) noexcept nogil>__nvmlDevicePowerSmoothingActivatePresetProfile)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7266
 *     global __nvmlDevicePowerSmoothingActivatePresetProfile
 *     _check_or_init_nvml()
 *     if __nvmlDevicePowerSmoothingActivatePresetProfile == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDevicePowerSmoothingActivatePresetProfile is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7269
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDevicePowerSmoothingActivatePresetProfile is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerSmoothingProfile_t*) noexcept nogil>__nvmlDevicePowerSmoothingActivatePresetProfile)(             # <<<<<<<<<<<<<<
 *         device, profile)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerSmoothingProfile_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDevicePowerSmoothingActivatePresetProfile)(__pyx_v_device, __pyx_v_profile);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7263
 * 
 * 
 * cdef nvmlReturn_t _nvmlDevicePowerSmoothingActivatePresetProfile(nvmlDevice_t device, nvmlPowerSmoothingProfile_t* profile) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDevicePowerSmoothingActivatePresetProfile
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDevicePowerSmoothingActivatePresetProfile", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7273
 * 
 * 
 * cdef nvmlReturn_t _nvmlDevicePowerSmoothingUpdatePresetProfileParam(nvmlDevice_t device, nvmlPowerSmoothingProfile_t* profile) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDevicePowerSmoothingUpdatePresetProfileParam
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDevicePowerSmoothingUpdatePresetProfileParam(nvmlDevice_t __pyx_v_device, nvmlPowerSmoothingProfile_t *__pyx_v_profile) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDevicePowerSmoothingUpdatePresetProfileParam", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7275
 * cdef nvmlReturn_t _nvmlDevicePowerSmoothingUpdatePresetProfileParam(nvmlDevice_t device, nvmlPowerSmoothingProfile_t* profile) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDevicePowerSmoothingUpdatePresetProfileParam
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDevicePowerSmoothingUpdatePresetProfileParam == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7275, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7276
 *     global __nvmlDevicePowerSmoothingUpdatePresetProfileParam
 *     _check_or_init_nvml()
 *     if __nvmlDevicePowerSmoothingUpdatePresetProfileParam == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDevicePowerSmoothingUpdatePresetProfileParam is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDevicePowerSmoothingUpdatePresetProfileParam == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7277
 *     _check_or_init_nvml()
 *     if __nvmlDevicePowerSmoothingUpdatePresetProfileParam == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDevicePowerSmoothingUpdatePresetProfileParam is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerSmoothingProfile_t*) noexcept nogil>__nvmlDevicePowerSmoothingUpdatePresetProfileParam)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7278
 *     if __nvmlDevicePowerSmoothingUpdatePresetProfileParam == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDevicePowerSmoothingUpdatePresetProfileParam is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerSmoothingProfile_t*) noexcept nogil>__nvmlDevicePowerSmoothingUpdatePresetProfileParam)(
 *         device, profile)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7278, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDevicePowerSmoothin_2};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7278, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7278, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7277
 *     _check_or_init_nvml()
 *     if __nvmlDevicePowerSmoothingUpdatePresetProfileParam == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDevicePowerSmoothingUpdatePresetProfileParam is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerSmoothingProfile_t*) noexcept nogil>__nvmlDevicePowerSmoothingUpdatePresetProfileParam)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7276
 *     global __nvmlDevicePowerSmoothingUpdatePresetProfileParam
 *     _check_or_init_nvml()
 *     if __nvmlDevicePowerSmoothingUpdatePresetProfileParam == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDevicePowerSmoothingUpdatePresetProfileParam is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7279
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDevicePowerSmoothingUpdatePresetProfileParam is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerSmoothingProfile_t*) noexcept nogil>__nvmlDevicePowerSmoothingUpdatePresetProfileParam)(             # <<<<<<<<<<<<<<
 *         device, profile)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerSmoothingProfile_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDevicePowerSmoothingUpdatePresetProfileParam)(__pyx_v_device, __pyx_v_profile);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7273
 * 
 * 
 * cdef nvmlReturn_t _nvmlDevicePowerSmoothingUpdatePresetProfileParam(nvmlDevice_t device, nvmlPowerSmoothingProfile_t* profile) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDevicePowerSmoothingUpdatePresetProfileParam
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDevicePowerSmoothingUpdatePresetProfileParam", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7283
 * 
 * 
 * cdef nvmlReturn_t _nvmlDevicePowerSmoothingSetState(nvmlDevice_t device, nvmlPowerSmoothingState_t* state) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDevicePowerSmoothingSetState
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDevicePowerSmoothingSetState(nvmlDevice_t __pyx_v_device, nvmlPowerSmoothingState_t *__pyx_v_state) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDevicePowerSmoothingSetState", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7285
 * cdef nvmlReturn_t _nvmlDevicePowerSmoothingSetState(nvmlDevice_t device, nvmlPowerSmoothingState_t* state) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDevicePowerSmoothingSetState
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDevicePowerSmoothingSetState == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7285, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7286
 *     global __nvmlDevicePowerSmoothingSetState
 *     _check_or_init_nvml()
 *     if __nvmlDevicePowerSmoothingSetState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDevicePowerSmoothingSetState is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDevicePowerSmoothingSetState == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7287
 *     _check_or_init_nvml()
 *     if __nvmlDevicePowerSmoothingSetState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDevicePowerSmoothingSetState is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerSmoothingState_t*) noexcept nogil>__nvmlDevicePowerSmoothingSetState)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7288
 *     if __nvmlDevicePowerSmoothingSetState == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDevicePowerSmoothingSetState is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerSmoothingState_t*) noexcept nogil>__nvmlDevicePowerSmoothingSetState)(
 *         device, state)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7288, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDevicePowerSmoothin_3};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7288, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7288, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7287
 *     _check_or_init_nvml()
 *     if __nvmlDevicePowerSmoothingSetState == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDevicePowerSmoothingSetState is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerSmoothingState_t*) noexcept nogil>__nvmlDevicePowerSmoothingSetState)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7286
 *     global __nvmlDevicePowerSmoothingSetState
 *     _check_or_init_nvml()
 *     if __nvmlDevicePowerSmoothingSetState == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDevicePowerSmoothingSetState is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7289
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDevicePowerSmoothingSetState is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerSmoothingState_t*) noexcept nogil>__nvmlDevicePowerSmoothingSetState)(             # <<<<<<<<<<<<<<
 *         device, state)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlPowerSmoothingState_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDevicePowerSmoothingSetState)(__pyx_v_device, __pyx_v_state);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7283
 * 
 * 
 * cdef nvmlReturn_t _nvmlDevicePowerSmoothingSetState(nvmlDevice_t device, nvmlPowerSmoothingState_t* state) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDevicePowerSmoothingSetState
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDevicePowerSmoothingSetState", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7293
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetAddressingMode(nvmlDevice_t device, nvmlDeviceAddressingMode_t* mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetAddressingMode
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetAddressingMode(nvmlDevice_t __pyx_v_device, nvmlDeviceAddressingMode_t *__pyx_v_mode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetAddressingMode", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7295
 * cdef nvmlReturn_t _nvmlDeviceGetAddressingMode(nvmlDevice_t device, nvmlDeviceAddressingMode_t* mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetAddressingMode
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetAddressingMode == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7295, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7296
 *     global __nvmlDeviceGetAddressingMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAddressingMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAddressingMode is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAddressingMode == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7297
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAddressingMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetAddressingMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceAddressingMode_t*) noexcept nogil>__nvmlDeviceGetAddressingMode)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7298
 *     if __nvmlDeviceGetAddressingMode == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAddressingMode is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceAddressingMode_t*) noexcept nogil>__nvmlDeviceGetAddressingMode)(
 *         device, mode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7298, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetAddressing};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7298, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7298, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7297
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAddressingMode == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetAddressingMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceAddressingMode_t*) noexcept nogil>__nvmlDeviceGetAddressingMode)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7296
 *     global __nvmlDeviceGetAddressingMode
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetAddressingMode == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAddressingMode is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7299
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetAddressingMode is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceAddressingMode_t*) noexcept nogil>__nvmlDeviceGetAddressingMode)(             # <<<<<<<<<<<<<<
 *         device, mode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlDeviceAddressingMode_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAddressingMode)(__pyx_v_device, __pyx_v_mode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7293
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetAddressingMode(nvmlDevice_t device, nvmlDeviceAddressingMode_t* mode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetAddressingMode
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetAddressingMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7303
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetRepairStatus(nvmlDevice_t device, nvmlRepairStatus_t* repairStatus) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetRepairStatus
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetRepairStatus(nvmlDevice_t __pyx_v_device, nvmlRepairStatus_t *__pyx_v_repairStatus) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetRepairStatus", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7305
 * cdef nvmlReturn_t _nvmlDeviceGetRepairStatus(nvmlDevice_t device, nvmlRepairStatus_t* repairStatus) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetRepairStatus
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetRepairStatus == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7305, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7306
 *     global __nvmlDeviceGetRepairStatus
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRepairStatus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRepairStatus is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRepairStatus == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7307
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRepairStatus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetRepairStatus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlRepairStatus_t*) noexcept nogil>__nvmlDeviceGetRepairStatus)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7308
 *     if __nvmlDeviceGetRepairStatus == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRepairStatus is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlRepairStatus_t*) noexcept nogil>__nvmlDeviceGetRepairStatus)(
 *         device, repairStatus)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7308, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetRepairStat};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7308, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7308, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7307
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRepairStatus == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetRepairStatus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlRepairStatus_t*) noexcept nogil>__nvmlDeviceGetRepairStatus)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7306
 *     global __nvmlDeviceGetRepairStatus
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetRepairStatus == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRepairStatus is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7309
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetRepairStatus is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlRepairStatus_t*) noexcept nogil>__nvmlDeviceGetRepairStatus)(             # <<<<<<<<<<<<<<
 *         device, repairStatus)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlRepairStatus_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRepairStatus)(__pyx_v_device, __pyx_v_repairStatus);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7303
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetRepairStatus(nvmlDevice_t device, nvmlRepairStatus_t* repairStatus) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetRepairStatus
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetRepairStatus", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7313
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPowerMizerMode_v1(nvmlDevice_t device, nvmlDevicePowerMizerModes_v1_t* powerMizerMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPowerMizerMode_v1
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPowerMizerMode_v1(nvmlDevice_t __pyx_v_device, nvmlDevicePowerMizerModes_v1_t *__pyx_v_powerMizerMode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetPowerMizerMode_v1", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7315
 * cdef nvmlReturn_t _nvmlDeviceGetPowerMizerMode_v1(nvmlDevice_t device, nvmlDevicePowerMizerModes_v1_t* powerMizerMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetPowerMizerMode_v1
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetPowerMizerMode_v1 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7315, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7316
 *     global __nvmlDeviceGetPowerMizerMode_v1
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerMizerMode_v1 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerMizerMode_v1 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerMizerMode_v1 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7317
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerMizerMode_v1 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerMizerMode_v1 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevicePowerMizerModes_v1_t*) noexcept nogil>__nvmlDeviceGetPowerMizerMode_v1)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7318
 *     if __nvmlDeviceGetPowerMizerMode_v1 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerMizerMode_v1 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevicePowerMizerModes_v1_t*) noexcept nogil>__nvmlDeviceGetPowerMizerMode_v1)(
 *         device, powerMizerMode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7318, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetPowerMizer};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7318, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7318, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7317
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerMizerMode_v1 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerMizerMode_v1 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevicePowerMizerModes_v1_t*) noexcept nogil>__nvmlDeviceGetPowerMizerMode_v1)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7316
 *     global __nvmlDeviceGetPowerMizerMode_v1
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPowerMizerMode_v1 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerMizerMode_v1 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7319
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPowerMizerMode_v1 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevicePowerMizerModes_v1_t*) noexcept nogil>__nvmlDeviceGetPowerMizerMode_v1)(             # <<<<<<<<<<<<<<
 *         device, powerMizerMode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlDevicePowerMizerModes_v1_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerMizerMode_v1)(__pyx_v_device, __pyx_v_powerMizerMode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7313
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPowerMizerMode_v1(nvmlDevice_t device, nvmlDevicePowerMizerModes_v1_t* powerMizerMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPowerMizerMode_v1
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetPowerMizerMode_v1", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7323
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetPowerMizerMode_v1(nvmlDevice_t device, nvmlDevicePowerMizerModes_v1_t* powerMizerMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetPowerMizerMode_v1
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetPowerMizerMode_v1(nvmlDevice_t __pyx_v_device, nvmlDevicePowerMizerModes_v1_t *__pyx_v_powerMizerMode) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetPowerMizerMode_v1", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7325
 * cdef nvmlReturn_t _nvmlDeviceSetPowerMizerMode_v1(nvmlDevice_t device, nvmlDevicePowerMizerModes_v1_t* powerMizerMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetPowerMizerMode_v1
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetPowerMizerMode_v1 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7325, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7326
 *     global __nvmlDeviceSetPowerMizerMode_v1
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetPowerMizerMode_v1 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetPowerMizerMode_v1 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPowerMizerMode_v1 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7327
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetPowerMizerMode_v1 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetPowerMizerMode_v1 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevicePowerMizerModes_v1_t*) noexcept nogil>__nvmlDeviceSetPowerMizerMode_v1)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7328
 *     if __nvmlDeviceSetPowerMizerMode_v1 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetPowerMizerMode_v1 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevicePowerMizerModes_v1_t*) noexcept nogil>__nvmlDeviceSetPowerMizerMode_v1)(
 *         device, powerMizerMode)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7328, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetPowerMizer};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7328, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7328, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7327
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetPowerMizerMode_v1 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetPowerMizerMode_v1 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevicePowerMizerModes_v1_t*) noexcept nogil>__nvmlDeviceSetPowerMizerMode_v1)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7326
 *     global __nvmlDeviceSetPowerMizerMode_v1
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetPowerMizerMode_v1 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetPowerMizerMode_v1 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7329
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetPowerMizerMode_v1 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlDevicePowerMizerModes_v1_t*) noexcept nogil>__nvmlDeviceSetPowerMizerMode_v1)(             # <<<<<<<<<<<<<<
 *         device, powerMizerMode)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlDevicePowerMizerModes_v1_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPowerMizerMode_v1)(__pyx_v_device, __pyx_v_powerMizerMode);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7323
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetPowerMizerMode_v1(nvmlDevice_t device, nvmlDevicePowerMizerModes_v1_t* powerMizerMode) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetPowerMizerMode_v1
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetPowerMizerMode_v1", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7333
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPdi(nvmlDevice_t device, nvmlPdi_t* pdi) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPdi
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPdi(nvmlDevice_t __pyx_v_device, nvmlPdi_t *__pyx_v_pdi) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetPdi", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7335
 * cdef nvmlReturn_t _nvmlDeviceGetPdi(nvmlDevice_t device, nvmlPdi_t* pdi) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetPdi
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetPdi == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7335, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7336
 *     global __nvmlDeviceGetPdi
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPdi == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPdi is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPdi == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7337
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPdi == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPdi is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPdi_t*) noexcept nogil>__nvmlDeviceGetPdi)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7338
 *     if __nvmlDeviceGetPdi == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPdi is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPdi_t*) noexcept nogil>__nvmlDeviceGetPdi)(
 *         device, pdi)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7338, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetPdi_is_not};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7338, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7338, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7337
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPdi == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetPdi is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPdi_t*) noexcept nogil>__nvmlDeviceGetPdi)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7336
 *     global __nvmlDeviceGetPdi
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetPdi == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPdi is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7339
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetPdi is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPdi_t*) noexcept nogil>__nvmlDeviceGetPdi)(             # <<<<<<<<<<<<<<
 *         device, pdi)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlPdi_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPdi)(__pyx_v_device, __pyx_v_pdi);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7333
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetPdi(nvmlDevice_t device, nvmlPdi_t* pdi) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetPdi
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetPdi", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7343
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetHostname_v1(nvmlDevice_t device, nvmlHostname_v1_t* hostname) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetHostname_v1
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetHostname_v1(nvmlDevice_t __pyx_v_device, nvmlHostname_v1_t *__pyx_v_hostname) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceSetHostname_v1", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7345
 * cdef nvmlReturn_t _nvmlDeviceSetHostname_v1(nvmlDevice_t device, nvmlHostname_v1_t* hostname) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceSetHostname_v1
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceSetHostname_v1 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7345, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7346
 *     global __nvmlDeviceSetHostname_v1
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetHostname_v1 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetHostname_v1 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetHostname_v1 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7347
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetHostname_v1 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetHostname_v1 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlHostname_v1_t*) noexcept nogil>__nvmlDeviceSetHostname_v1)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7348
 *     if __nvmlDeviceSetHostname_v1 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetHostname_v1 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlHostname_v1_t*) noexcept nogil>__nvmlDeviceSetHostname_v1)(
 *         device, hostname)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7348, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceSetHostname_v};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7348, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7348, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7347
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetHostname_v1 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceSetHostname_v1 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlHostname_v1_t*) noexcept nogil>__nvmlDeviceSetHostname_v1)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7346
 *     global __nvmlDeviceSetHostname_v1
 *     _check_or_init_nvml()
 *     if __nvmlDeviceSetHostname_v1 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetHostname_v1 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7349
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceSetHostname_v1 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlHostname_v1_t*) noexcept nogil>__nvmlDeviceSetHostname_v1)(             # <<<<<<<<<<<<<<
 *         device, hostname)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlHostname_v1_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetHostname_v1)(__pyx_v_device, __pyx_v_hostname);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7343
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceSetHostname_v1(nvmlDevice_t device, nvmlHostname_v1_t* hostname) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceSetHostname_v1
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceSetHostname_v1", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7353
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetHostname_v1(nvmlDevice_t device, nvmlHostname_v1_t* hostname) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetHostname_v1
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetHostname_v1(nvmlDevice_t __pyx_v_device, nvmlHostname_v1_t *__pyx_v_hostname) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetHostname_v1", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7355
 * cdef nvmlReturn_t _nvmlDeviceGetHostname_v1(nvmlDevice_t device, nvmlHostname_v1_t* hostname) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetHostname_v1
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetHostname_v1 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7355, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7356
 *     global __nvmlDeviceGetHostname_v1
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHostname_v1 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHostname_v1 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHostname_v1 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7357
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHostname_v1 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetHostname_v1 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlHostname_v1_t*) noexcept nogil>__nvmlDeviceGetHostname_v1)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7358
 *     if __nvmlDeviceGetHostname_v1 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHostname_v1 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlHostname_v1_t*) noexcept nogil>__nvmlDeviceGetHostname_v1)(
 *         device, hostname)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7358, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetHostname_v};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7358, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7358, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7357
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHostname_v1 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetHostname_v1 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlHostname_v1_t*) noexcept nogil>__nvmlDeviceGetHostname_v1)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7356
 *     global __nvmlDeviceGetHostname_v1
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetHostname_v1 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHostname_v1 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7359
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetHostname_v1 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlHostname_v1_t*) noexcept nogil>__nvmlDeviceGetHostname_v1)(             # <<<<<<<<<<<<<<
 *         device, hostname)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlHostname_v1_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHostname_v1)(__pyx_v_device, __pyx_v_hostname);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7353
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetHostname_v1(nvmlDevice_t device, nvmlHostname_v1_t* hostname) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetHostname_v1
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetHostname_v1", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7363
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetNvLinkInfo(nvmlDevice_t device, nvmlNvLinkInfo_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetNvLinkInfo
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetNvLinkInfo(nvmlDevice_t __pyx_v_device, nvmlNvLinkInfo_t *__pyx_v_info) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetNvLinkInfo", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7365
 * cdef nvmlReturn_t _nvmlDeviceGetNvLinkInfo(nvmlDevice_t device, nvmlNvLinkInfo_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetNvLinkInfo
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetNvLinkInfo == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7365, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7366
 *     global __nvmlDeviceGetNvLinkInfo
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkInfo is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkInfo == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7367
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlNvLinkInfo_t*) noexcept nogil>__nvmlDeviceGetNvLinkInfo)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7368
 *     if __nvmlDeviceGetNvLinkInfo == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkInfo is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlNvLinkInfo_t*) noexcept nogil>__nvmlDeviceGetNvLinkInfo)(
 *         device, info)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7368, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetNvLinkInfo};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7368, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7368, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7367
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkInfo == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlNvLinkInfo_t*) noexcept nogil>__nvmlDeviceGetNvLinkInfo)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7366
 *     global __nvmlDeviceGetNvLinkInfo
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetNvLinkInfo == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkInfo is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7369
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetNvLinkInfo is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlNvLinkInfo_t*) noexcept nogil>__nvmlDeviceGetNvLinkInfo)(             # <<<<<<<<<<<<<<
 *         device, info)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlNvLinkInfo_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkInfo)(__pyx_v_device, __pyx_v_info);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7363
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetNvLinkInfo(nvmlDevice_t device, nvmlNvLinkInfo_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetNvLinkInfo
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetNvLinkInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7373
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceReadWritePRM_v1(nvmlDevice_t device, nvmlPRMTLV_v1_t* buffer) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceReadWritePRM_v1
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceReadWritePRM_v1(nvmlDevice_t __pyx_v_device, nvmlPRMTLV_v1_t *__pyx_v_buffer) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceReadWritePRM_v1", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7375
 * cdef nvmlReturn_t _nvmlDeviceReadWritePRM_v1(nvmlDevice_t device, nvmlPRMTLV_v1_t* buffer) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceReadWritePRM_v1
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceReadWritePRM_v1 == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7375, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7376
 *     global __nvmlDeviceReadWritePRM_v1
 *     _check_or_init_nvml()
 *     if __nvmlDeviceReadWritePRM_v1 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceReadWritePRM_v1 is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceReadWritePRM_v1 == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7377
 *     _check_or_init_nvml()
 *     if __nvmlDeviceReadWritePRM_v1 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceReadWritePRM_v1 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPRMTLV_v1_t*) noexcept nogil>__nvmlDeviceReadWritePRM_v1)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7378
 *     if __nvmlDeviceReadWritePRM_v1 == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceReadWritePRM_v1 is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPRMTLV_v1_t*) noexcept nogil>__nvmlDeviceReadWritePRM_v1)(
 *         device, buffer)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7378, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceReadWritePRM};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7378, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7378, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7377
 *     _check_or_init_nvml()
 *     if __nvmlDeviceReadWritePRM_v1 == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceReadWritePRM_v1 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPRMTLV_v1_t*) noexcept nogil>__nvmlDeviceReadWritePRM_v1)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7376
 *     global __nvmlDeviceReadWritePRM_v1
 *     _check_or_init_nvml()
 *     if __nvmlDeviceReadWritePRM_v1 == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceReadWritePRM_v1 is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7379
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceReadWritePRM_v1 is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlPRMTLV_v1_t*) noexcept nogil>__nvmlDeviceReadWritePRM_v1)(             # <<<<<<<<<<<<<<
 *         device, buffer)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlPRMTLV_v1_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceReadWritePRM_v1)(__pyx_v_device, __pyx_v_buffer);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7373
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceReadWritePRM_v1(nvmlDevice_t device, nvmlPRMTLV_v1_t* buffer) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceReadWritePRM_v1
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceReadWritePRM_v1", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7383
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGpuInstanceProfileInfoByIdV(nvmlDevice_t device, unsigned int profileId, nvmlGpuInstanceProfileInfo_v2_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGpuInstanceProfileInfoByIdV
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGpuInstanceProfileInfoByIdV(nvmlDevice_t __pyx_v_device, unsigned int __pyx_v_profileId, nvmlGpuInstanceProfileInfo_v2_t *__pyx_v_info) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetGpuInstanceProfileInfoByIdV", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7385
 * cdef nvmlReturn_t _nvmlDeviceGetGpuInstanceProfileInfoByIdV(nvmlDevice_t device, unsigned int profileId, nvmlGpuInstanceProfileInfo_v2_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetGpuInstanceProfileInfoByIdV
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetGpuInstanceProfileInfoByIdV == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7385, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7386
 *     global __nvmlDeviceGetGpuInstanceProfileInfoByIdV
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstanceProfileInfoByIdV == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceProfileInfoByIdV is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceProfileInfoByIdV == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7387
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstanceProfileInfoByIdV == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceProfileInfoByIdV is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstanceProfileInfo_v2_t*) noexcept nogil>__nvmlDeviceGetGpuInstanceProfileInfoByIdV)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7388
 *     if __nvmlDeviceGetGpuInstanceProfileInfoByIdV == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceProfileInfoByIdV is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstanceProfileInfo_v2_t*) noexcept nogil>__nvmlDeviceGetGpuInstanceProfileInfoByIdV)(
 *         device, profileId, info)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7388, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetGpuInstanc_7};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7388, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7388, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7387
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstanceProfileInfoByIdV == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceProfileInfoByIdV is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstanceProfileInfo_v2_t*) noexcept nogil>__nvmlDeviceGetGpuInstanceProfileInfoByIdV)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7386
 *     global __nvmlDeviceGetGpuInstanceProfileInfoByIdV
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetGpuInstanceProfileInfoByIdV == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceProfileInfoByIdV is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7389
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetGpuInstanceProfileInfoByIdV is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstanceProfileInfo_v2_t*) noexcept nogil>__nvmlDeviceGetGpuInstanceProfileInfoByIdV)(             # <<<<<<<<<<<<<<
 *         device, profileId, info)
 * 
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, unsigned int, nvmlGpuInstanceProfileInfo_v2_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceProfileInfoByIdV)(__pyx_v_device, __pyx_v_profileId, __pyx_v_info);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7383
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetGpuInstanceProfileInfoByIdV(nvmlDevice_t device, unsigned int profileId, nvmlGpuInstanceProfileInfo_v2_t* info) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetGpuInstanceProfileInfoByIdV
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetGpuInstanceProfileInfoByIdV", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}

/* "cuda/bindings/_internal/_nvml.pyx":7393
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts(nvmlDevice_t device, nvmlEccSramUniqueUncorrectedErrorCounts_t* errorCounts) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts
 *     _check_or_init_nvml()
*/

static nvmlReturn_t __pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts(nvmlDevice_t __pyx_v_device, nvmlEccSramUniqueUncorrectedErrorCounts_t *__pyx_v_errorCounts) {
  nvmlReturn_t __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  size_t __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyGILState_STATE __pyx_gilstate_save;
  __Pyx_RefNannySetupContext("_nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts", 1);

  /* "cuda/bindings/_internal/_nvml.pyx":7395
 * cdef nvmlReturn_t _nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts(nvmlDevice_t device, nvmlEccSramUniqueUncorrectedErrorCounts_t* errorCounts) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:
 *     global __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts
 *     _check_or_init_nvml()             # <<<<<<<<<<<<<<
 *     if __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts == NULL:
 *         with gil:
*/
  __pyx_t_1 = __pyx_f_4cuda_8bindings_9_internal_5_nvml__check_or_init_nvml(); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 7395, __pyx_L1_error)

  /* "cuda/bindings/_internal/_nvml.pyx":7396
 *     global __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts is not found")
*/
  __pyx_t_2 = (__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts == NULL);
  if (unlikely(__pyx_t_2)) {

    /* "cuda/bindings/_internal/_nvml.pyx":7397
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEccSramUniqueUncorrectedErrorCounts_t*) noexcept nogil>__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts)(
*/
    {
        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
        /*try:*/ {

          /* "cuda/bindings/_internal/_nvml.pyx":7398
 *     if __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts == NULL:
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts is not found")             # <<<<<<<<<<<<<<
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEccSramUniqueUncorrectedErrorCounts_t*) noexcept nogil>__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts)(
 *         device, errorCounts)
*/
          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_FunctionNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 7398, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_5);
          __pyx_t_6 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_5))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
            __pyx_t_6 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_function_nvmlDeviceGetSramUnique};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7398, __pyx_L5_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_Raise(__pyx_t_3, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __PYX_ERR(0, 7398, __pyx_L5_error)
        }

        /* "cuda/bindings/_internal/_nvml.pyx":7397
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts == NULL:
 *         with gil:             # <<<<<<<<<<<<<<
 *             raise FunctionNotFoundError("function nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEccSramUniqueUncorrectedErrorCounts_t*) noexcept nogil>__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts)(
*/
        /*finally:*/ {
          __pyx_L5_error: {
            __Pyx_PyGILState_Release(__pyx_gilstate_save);
            goto __pyx_L1_error;
          }
        }
    }

    /* "cuda/bindings/_internal/_nvml.pyx":7396
 *     global __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts
 *     _check_or_init_nvml()
 *     if __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts == NULL:             # <<<<<<<<<<<<<<
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts is not found")
*/
  }

  /* "cuda/bindings/_internal/_nvml.pyx":7399
 *         with gil:
 *             raise FunctionNotFoundError("function nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts is not found")
 *     return (<nvmlReturn_t (*)(nvmlDevice_t, nvmlEccSramUniqueUncorrectedErrorCounts_t*) noexcept nogil>__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts)(             # <<<<<<<<<<<<<<
 *         device, errorCounts)
*/
  __pyx_r = ((nvmlReturn_t (*)(nvmlDevice_t, nvmlEccSramUniqueUncorrectedErrorCounts_t *))__pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts)(__pyx_v_device, __pyx_v_errorCounts);
  goto __pyx_L0;

  /* "cuda/bindings/_internal/_nvml.pyx":7393
 * 
 * 
 * cdef nvmlReturn_t _nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts(nvmlDevice_t device, nvmlEccSramUniqueUncorrectedErrorCounts_t* errorCounts) except?_NVMLRETURN_T_INTERNAL_LOADING_ERROR nogil:             # <<<<<<<<<<<<<<
 *     global __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts
 *     _check_or_init_nvml()
*/

  /* function exit code */
  __pyx_L1_error:;
  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("cuda.bindings._internal._nvml._nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = _NVMLRETURN_T_INTERNAL_LOADING_ERROR;
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  __pyx_L0:;
  __Pyx_RefNannyFinishContextNogil()
  return __pyx_r;
}
/* #### Code section: module_exttypes ### */

static PyMethodDef __pyx_methods[] = {
  {0, 0, 0, 0}
};
/* #### Code section: initfunc_declarations ### */
static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate); /*proto*/
static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/
static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void); /*proto*/
static CYTHON_SMALL_CODE int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/
static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/
static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/
static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/
static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/
static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/
static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/
static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/
static CYTHON_SMALL_CODE int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate); /*proto*/
/* #### Code section: init_module ### */

static int __Pyx_modinit_global_init_code(__pyx_mstatetype *__pyx_mstate) {
  __Pyx_RefNannyDeclarations
  CYTHON_UNUSED_VAR(__pyx_mstate);
  __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0);
  /*--- Global init code ---*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___symbol_lock = Py_None; Py_INCREF(Py_None);
  __pyx_v_4cuda_8bindings_9_internal_5_nvml_func_ptrs = ((PyObject*)Py_None); Py_INCREF(Py_None);
  __Pyx_RefNannyFinishContext();
  return 0;
}

static int __Pyx_modinit_variable_export_code(__pyx_mstatetype *__pyx_mstate) {
  __Pyx_RefNannyDeclarations
  CYTHON_UNUSED_VAR(__pyx_mstate);
  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0);
  /*--- Variable export code ---*/
  __Pyx_RefNannyFinishContext();
  return 0;
}

static int __Pyx_modinit_function_export_code(__pyx_mstatetype *__pyx_mstate) {
  __Pyx_RefNannyDeclarations
  CYTHON_UNUSED_VAR(__pyx_mstate);
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0);
  /*--- Function export code ---*/
  {
    __pyx_t_1 = __Pyx_ApiExport_GetApiDict(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    const char * __pyx_export_signature = __Pyx_PyBytes_AsString(__pyx_mstate_global->__pyx_kp_b_char_const_nvmlReturn_t_nvmlRetu);
    #if !CYTHON_ASSUME_SAFE_MACROS
    if (unlikely(!__pyx_export_signature)) __PYX_ERR(0, 1, __pyx_L1_error)
    #endif
    const char * __pyx_export_name = __pyx_export_signature + 14397;
    void (*const __pyx_export_pointers[])(void) = {(void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlErrorString, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetDriverVersion, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetNVMLVersion, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetHandleByPciBusId_v2, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetHandleBySerial, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetHandleByUUID, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetCudaDriverVersion, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetCudaDriverVersion_v2, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlComputeInstanceDestroy, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlComputeInstanceGetInfo_v2, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetConfComputeKeyRotationThresholdInfo, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemSetConfComputeKeyRotationThresholdInfo, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetConfComputeCapabilities, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetConfComputeState, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceClearAccountingPids, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceClearCpuAffinity, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceResetGpuLockedClocks, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceResetMemoryLockedClocks, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetCpuAffinity, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceValidateInforom, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGspFirmwareVersion, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPgpuMetadataString, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetBoardPartNumber, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetInforomImageVersion, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetName, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetSerial, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetUUID, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVbiosVersion, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGpcClkVfOffset, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMemClkVfOffset, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetCudaComputeCapability, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGpcClkMinMaxVfOffset, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMemClkMinMaxVfOffset, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceClearFieldValues, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetFieldValues, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetBAR1MemoryInfo, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetBrand, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetBridgeChipInfo, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetBusType, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetC2cModeInfoV, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetClkMonStatus, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetClockOffsets, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetClockOffsets, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetClock, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMinMaxClockOfPState, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetClockInfo, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMaxClockInfo, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMaxCustomerBoostClock, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetComputeMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetComputeMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetConfComputeGpuAttestationReport, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetConfComputeGpuCertificate, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetConfComputeMemSizeInfo, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetCoolerInfo, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetAddressingMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetArchitecture, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetAttributes_v2, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetCapabilities, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetCurrentClockFreqs, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPerformanceModes, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPowerMizerMode_v1, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetPowerMizerMode_v1, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetVgpuCapabilities, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVgpuCapabilities, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetDeviceHandleFromMigDeviceHandle, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceOnSameBoard, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetP2PStatus, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetTopologyCommonAncestor, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetDramEncryptionMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetDramEncryptionMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetDriverModel_v2, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetDriverModel, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceClearEccErrorCounts, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetSramEccErrorStatus, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetAccountingMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetDefaultEccMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetDisplayActive, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetDisplayMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPersistenceMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetRetiredPagesPendingStatus, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetAutoBoostedClocksEnabled, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetEccMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetAccountingMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetAutoBoostedClocksEnabled, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetEccMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetPersistenceMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetDefaultAutoBoostedClocksEnabled, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetEncoderCapacity, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetFBCStats, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetFanSpeedRPM, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpmSampleGet, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpmQueryDeviceSupport, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetDynamicPstatesInfo, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGpuFabricInfoV, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGpuOperationMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetGpuOperationMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetTopologyNearestGpus, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVirtualizationMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetVirtualizationMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGridLicensableFeatures_v4, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetHostVgpuMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetHostname_v1, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetHostname_v1, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetInforomVersion, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMarginTemperature, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMemoryErrorCounter, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetTotalEccErrors, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetConfComputeProtectedMemoryUsage, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMemoryInfo_v2, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetNvLinkInfo, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetNvLinkDeviceLowPowerThreshold, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetNvlinkBwMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetNvlinkBwMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetNvlinkSupportedBwModes, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceReadWritePRM_v1, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetRetiredPages, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetRetiredPages_v2, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPciInfoExt, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPciInfo_v3, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPcieThroughput, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPdi, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPlatformInfo, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDevicePowerSmoothingActivatePresetProfile, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDevicePowerSmoothingUpdatePresetProfileParam, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDevicePowerSmoothingSetState, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPowerSource, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetPowerManagementLimit_v2, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetRunningProcessDetailList, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetProcessUtilization, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetProcessesUtilizationInfo, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPerformanceState, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPowerState, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetSupportedPerformanceStates, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetRepairStatus, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetAPIRestriction, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetAPIRestriction, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetRowRemapperHistogram, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetSamples, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetTemperatureThreshold, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetTemperatureThreshold, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetTemperatureV, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetUtilizationRates, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVgpuHeterogeneousMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetVgpuHeterogeneousMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVgpuInstancesUtilizationInfo, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVgpuMetadata, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVgpuProcessesUtilizationInfo, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVgpuSchedulerCapabilities, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVgpuSchedulerState, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVgpuSchedulerLog, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetVgpuSchedulerState, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVgpuTypeCreatablePlacements, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVgpuTypeSupportedPlacements, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetMaxInstances, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceWorkloadPowerProfileClearRequestedProfiles, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetCurrentClocksEventReasons, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetSupportedClocksEventReasons, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetSupportedEventTypes, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetTotalEnergyConsumption, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetLastBBXFlushTime, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetConfComputeUnprotectedMemSize, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceRegisterEvents, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVgpuUtilization, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetVgpuProcessUtilization, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetAccountingBufferSize, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetAdaptiveClockInfoStatus, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetBoardId, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetComputeInstanceId, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetCurrPcieLinkGeneration, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetCurrPcieLinkWidth, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetEnforcedPowerLimit, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetFanSpeed, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGpuInstanceId, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGpuMaxPcieLinkGeneration, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetIndex, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetInforomConfigurationChecksum, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetIrqNum, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMaxMigDeviceCount, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMaxPcieLinkGeneration, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMaxPcieLinkWidth, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMemoryBusWidth, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMinorNumber, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetModuleId, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMultiGpuBoard, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetNumFans, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetNumGpuCores, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetNumaNodeId, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPcieLinkMaxSpeed, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPcieReplayCounter, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPcieSpeed, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPowerManagementDefaultLimit, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPowerManagementLimit, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPowerUsage, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceIsMigDeviceHandle, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpmQueryIfStreamingEnabled, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetEncoderSessions, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetFBCSessions, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetComputeRunningProcesses_v3, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMPSComputeRunningProcesses_v3, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetActiveVgpus, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetCreatableVgpus, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetSupportedVgpus, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetAccountingPids, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetDecoderUtilization, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetEncoderUtilization, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGspFirmwareMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetJpgUtilization, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMigMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMinMaxFanSpeed, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetOfaUtilization, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetPowerManagementLimitConstraints, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetSupportedMemoryClocks, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetEncoderStats, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetRemappedRows, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceResetNvLinkErrorCounters, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetDefaultFanSpeed_v2, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetPowerManagementLimit, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpmSetStreamingEnabled, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetAccountingStats, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMigDeviceHandleByIndex, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetNvLinkState, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetFanControlPolicy_v2, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetFanControlPolicy, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpmMigSampleGet, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGpuInstancePossiblePlacements_v2, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceCreateGpuInstanceWithPlacement, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGpuInstanceProfileInfoByIdV, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGpuInstanceProfileInfoV, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceCreateGpuInstance, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGpuInstanceById, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGpuInstances, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetThermalSettings, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetNvLinkRemoteDeviceType, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetNvLinkCapability, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetNvLinkErrorCounter, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetNvLinkRemotePciInfo_v2, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetMigMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetFanSpeed_v2, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetGpuInstanceRemainingCapacity, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetNvLinkVersion, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetTargetFanSpeed, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetSupportedGraphicsClocks, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetFanSpeed_v2, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetGpuLockedClocks, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceSetMemoryLockedClocks, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetCpuAffinity, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetCpuAffinityWithinScope, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetMemoryAffinity, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlEventSetCreate, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlEventSetFree, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlEventSetWait_v2, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceDestroy, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceGetActiveVgpus, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceGetInfo, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceGetVgpuTypeCreatablePlacements, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceGetVgpuHeterogeneousMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceSetVgpuHeterogeneousMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceGetVgpuSchedulerLog, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceGetVgpuSchedulerState, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceSetVgpuSchedulerState, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceGetCreatableVgpus, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceGetComputeInstancePossiblePlacements, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceCreateComputeInstanceWithPlacement, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceCreateComputeInstance, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceGetComputeInstanceById, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceGetComputeInstances, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceGetComputeInstanceRemainingCapacity, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGpuInstanceGetComputeInstanceProfileInfoV, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceDiscoverGpus, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceRemoveGpu_v2, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceQueryDrainState, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceModifyDrainState, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetConfComputeSettings, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetDriverBranch, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemEventSetCreate, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemEventSetFree, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemEventSetWait, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemRegisterEvents, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetHandleByUUIDV, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlUnitSetLedState, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlUnitGetLedState, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlUnitGetPsuInfo, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlUnitGetFanSpeedInfo, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlUnitGetUnitInfo, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlUnitGetDevices, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlUnitGetTemperature, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGetVgpuDriverCapabilities, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceClearAccountingPids, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetGpuPciId, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetMdevUUID, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetUUID, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetVmDriverVersion, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetVmID, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetAccountingMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetEccMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetFBCStats, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetLicenseInfo_v2, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetMetadata, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetPlacementId, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetRuntimeStateSize, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetType, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetFbUsage, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetEncoderCapacity, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetFrameRateLimit, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetGpuInstanceId, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetLicenseStatus, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetEncoderSessions, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetFBCSessions, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetAccountingPids, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetEncoderStats, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceSetEncoderCapacity, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuInstanceGetAccountingStats, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGetVgpuCompatibility, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetClass, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetName, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetLicense, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetCapabilities, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetBAR1Info, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetFbReservation, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetFramebufferSize, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetGspHeapSize, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetDeviceID, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetFrameRateLimit, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetGpuInstanceProfileId, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetMaxInstancesPerVm, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetNumDisplayHeads, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetResolution, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlVgpuTypeGetMaxInstancesPerGpuInstance, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSetVgpuVersion, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGetVgpuVersion, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetCount_v2, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGetExcludedDeviceCount, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetConfComputeGpusReadyState, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetNvlinkBwMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlUnitGetCount, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetHicVersion, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlInitWithFlags, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemSetConfComputeGpusReadyState, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemSetNvlinkBwMode, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetProcessName, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlDeviceGetHandleByIndex_v2, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlGetExcludedDeviceInfoByIndex, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlUnitGetHandleByIndex, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlSystemGetTopologyGpuSet, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlInit_v2, (void (*)(void))&__pyx_f_4cuda_8bindings_9_internal_5_nvml__nvmlShutdown, (void (*)(void)) NULL};
    void (*const *__pyx_export_pointer)(void) = __pyx_export_pointers;
    const char *__pyx_export_current_signature = __pyx_export_signature;
    while (*__pyx_export_pointer) {
      if (__Pyx_ExportFunction(__pyx_t_1, __pyx_export_name, *__pyx_export_pointer, __pyx_export_current_signature) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
      ++__pyx_export_pointer;
      __pyx_export_name = strchr(__pyx_export_name, '\0') + 1;
      __pyx_export_signature = strchr(__pyx_export_signature, '\0') + 1;
      if (*__pyx_export_signature != '\0') __pyx_export_current_signature = __pyx_export_signature;
    }
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  }
  __Pyx_RefNannyFinishContext();
  return 0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_RefNannyFinishContext();
  return -1;
}

static int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate) {
  __Pyx_RefNannyDeclarations
  CYTHON_UNUSED_VAR(__pyx_mstate);
  __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
  /*--- Type init code ---*/
  __Pyx_RefNannyFinishContext();
  return 0;
}

static int __Pyx_modinit_type_import_code(__pyx_mstatetype *__pyx_mstate) {
  __Pyx_RefNannyDeclarations
  CYTHON_UNUSED_VAR(__pyx_mstate);
  __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0);
  /*--- Type import code ---*/
  __Pyx_RefNannyFinishContext();
  return 0;
}

static int __Pyx_modinit_variable_import_code(__pyx_mstatetype *__pyx_mstate) {
  __Pyx_RefNannyDeclarations
  CYTHON_UNUSED_VAR(__pyx_mstate);
  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0);
  /*--- Variable import code ---*/
  __Pyx_RefNannyFinishContext();
  return 0;
}

static int __Pyx_modinit_function_import_code(__pyx_mstatetype *__pyx_mstate) {
  __Pyx_RefNannyDeclarations
  CYTHON_UNUSED_VAR(__pyx_mstate);
  __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0);
  /*--- Function import code ---*/
  __Pyx_RefNannyFinishContext();
  return 0;
}

#if CYTHON_PEP489_MULTI_PHASE_INIT
static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
static int __pyx_pymod_exec__nvml(PyObject* module); /*proto*/
static PyModuleDef_Slot __pyx_moduledef_slots[] = {
  {Py_mod_create, (void*)__pyx_pymod_create},
  {Py_mod_exec, (void*)__pyx_pymod_exec__nvml},
  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
  {Py_mod_gil, Py_MOD_GIL_NOT_USED},
  #endif
  #if PY_VERSION_HEX >= 0x030C0000 && CYTHON_USE_MODULE_STATE
  {Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED},
  #endif
  {0, NULL}
};
#endif

#ifdef __cplusplus
namespace {
  struct PyModuleDef __pyx_moduledef =
  #else
  static struct PyModuleDef __pyx_moduledef =
  #endif
  {
      PyModuleDef_HEAD_INIT,
      "_nvml",
      0, /* m_doc */
    #if CYTHON_USE_MODULE_STATE
      sizeof(__pyx_mstatetype), /* m_size */
    #else
      (CYTHON_PEP489_MULTI_PHASE_INIT) ? 0 : -1, /* m_size */
    #endif
      __pyx_methods /* m_methods */,
    #if CYTHON_PEP489_MULTI_PHASE_INIT
      __pyx_moduledef_slots, /* m_slots */
    #else
      NULL, /* m_reload */
    #endif
    #if CYTHON_USE_MODULE_STATE
      __pyx_m_traverse, /* m_traverse */
      __pyx_m_clear, /* m_clear */
      NULL /* m_free */
    #else
      NULL, /* m_traverse */
      NULL, /* m_clear */
      NULL /* m_free */
    #endif
  };
  #ifdef __cplusplus
} /* anonymous namespace */
#endif

/* PyModInitFuncType */
#ifndef CYTHON_NO_PYINIT_EXPORT
  #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
#else
  #ifdef __cplusplus
  #define __Pyx_PyMODINIT_FUNC extern "C" PyObject *
  #else
  #define __Pyx_PyMODINIT_FUNC PyObject *
  #endif
#endif

__Pyx_PyMODINIT_FUNC PyInit__nvml(void) CYTHON_SMALL_CODE; /*proto*/
__Pyx_PyMODINIT_FUNC PyInit__nvml(void)
#if CYTHON_PEP489_MULTI_PHASE_INIT
{
  return PyModuleDef_Init(&__pyx_moduledef);
}
/* ModuleCreationPEP489 */
#if CYTHON_COMPILING_IN_LIMITED_API && (__PYX_LIMITED_VERSION_HEX < 0x03090000\
      || ((defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS)) && __PYX_LIMITED_VERSION_HEX < 0x030A0000))
static PY_INT64_T __Pyx_GetCurrentInterpreterId(void) {
    {
        PyObject *module = PyImport_ImportModule("_interpreters"); // 3.13+ I think
        if (!module) {
            PyErr_Clear(); // just try the 3.8-3.12 version
            module = PyImport_ImportModule("_xxsubinterpreters");
            if (!module) goto bad;
        }
        PyObject *current = PyObject_CallMethod(module, "get_current", NULL);
        Py_DECREF(module);
        if (!current) goto bad;
        if (PyTuple_Check(current)) {
            PyObject *new_current = PySequence_GetItem(current, 0);
            Py_DECREF(current);
            current = new_current;
            if (!new_current) goto bad;
        }
        long long as_c_int = PyLong_AsLongLong(current);
        Py_DECREF(current);
        return as_c_int;
    }
  bad:
    PySys_WriteStderr("__Pyx_GetCurrentInterpreterId failed. Try setting the C define CYTHON_PEP489_MULTI_PHASE_INIT=0\n");
    return -1;
}
#endif
#if !CYTHON_USE_MODULE_STATE
static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
    static PY_INT64_T main_interpreter_id = -1;
#if CYTHON_COMPILING_IN_GRAAL && defined(GRAALPY_VERSION_NUM) && GRAALPY_VERSION_NUM > 0x19000000
    PY_INT64_T current_id = GraalPyInterpreterState_GetIDFromThreadState(PyThreadState_Get());
#elif CYTHON_COMPILING_IN_GRAAL
    PY_INT64_T current_id = PyInterpreterState_GetIDFromThreadState(PyThreadState_Get());
#elif CYTHON_COMPILING_IN_LIMITED_API && (__PYX_LIMITED_VERSION_HEX < 0x03090000\
      || ((defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS)) && __PYX_LIMITED_VERSION_HEX < 0x030A0000))
    PY_INT64_T current_id = __Pyx_GetCurrentInterpreterId();
#elif CYTHON_COMPILING_IN_LIMITED_API
    PY_INT64_T current_id = PyInterpreterState_GetID(PyInterpreterState_Get());
#else
    PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp);
#endif
    if (unlikely(current_id == -1)) {
        return -1;
    }
    if (main_interpreter_id == -1) {
        main_interpreter_id = current_id;
        return 0;
    } else if (unlikely(main_interpreter_id != current_id)) {
        PyErr_SetString(
            PyExc_ImportError,
            "Interpreter change detected - this module can only be loaded into one interpreter per process.");
        return -1;
    }
    return 0;
}
#endif
static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none)
{
    PyObject *value = PyObject_GetAttrString(spec, from_name);
    int result = 0;
    if (likely(value)) {
        if (allow_none || value != Py_None) {
            result = PyDict_SetItemString(moddict, to_name, value);
        }
        Py_DECREF(value);
    } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
        PyErr_Clear();
    } else {
        result = -1;
    }
    return result;
}
static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) {
    PyObject *module = NULL, *moddict, *modname;
    CYTHON_UNUSED_VAR(def);
    #if !CYTHON_USE_MODULE_STATE
    if (__Pyx_check_single_interpreter())
        return NULL;
    #endif
    if (__pyx_m)
        return __Pyx_NewRef(__pyx_m);
    modname = PyObject_GetAttrString(spec, "name");
    if (unlikely(!modname)) goto bad;
    module = PyModule_NewObject(modname);
    Py_DECREF(modname);
    if (unlikely(!module)) goto bad;
    moddict = PyModule_GetDict(module);
    if (unlikely(!moddict)) goto bad;
    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad;
    return module;
bad:
    Py_XDECREF(module);
    return NULL;
}


static CYTHON_SMALL_CODE int __pyx_pymod_exec__nvml(PyObject *__pyx_pyinit_module)
#endif
{
  int stringtab_initialized = 0;
  #if CYTHON_USE_MODULE_STATE
  int pystate_addmodule_run = 0;
  #endif
  __pyx_mstatetype *__pyx_mstate = NULL;
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  Py_ssize_t __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  size_t __pyx_t_7;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannyDeclarations
  #if CYTHON_PEP489_MULTI_PHASE_INIT
  if (__pyx_m) {
    if (__pyx_m == __pyx_pyinit_module) return 0;
    PyErr_SetString(PyExc_RuntimeError, "Module '_nvml' has already been imported. Re-initialisation is not supported.");
    return -1;
  }
  #else
  if (__pyx_m) return __Pyx_NewRef(__pyx_m);
  #endif
  /*--- Module creation code ---*/
  #if CYTHON_PEP489_MULTI_PHASE_INIT
  __pyx_t_1 = __pyx_pyinit_module;
  Py_INCREF(__pyx_t_1);
  #else
  __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #if CYTHON_USE_MODULE_STATE
  {
    int add_module_result = __Pyx_State_AddModule(__pyx_t_1, &__pyx_moduledef);
    __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "_nvml" pseudovariable */
    if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
    pystate_addmodule_run = 1;
  }
  #else
  __pyx_m = __pyx_t_1;
  #endif
  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
  PyUnstable_Module_SetGIL(__pyx_m, Py_MOD_GIL_NOT_USED);
  #endif
  __pyx_mstate = __pyx_mstate_global;
  CYTHON_UNUSED_VAR(__pyx_t_1);
  __pyx_mstate->__pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_mstate->__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
  Py_INCREF(__pyx_mstate->__pyx_d);
  __pyx_mstate->__pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_mstate->__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_mstate->__pyx_cython_runtime = __Pyx_PyImport_AddModuleRef("cython_runtime"); if (unlikely(!__pyx_mstate->__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_mstate->__pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  /* ImportRefnannyAPI */
  #if CYTHON_REFNANNY
  __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
  if (!__Pyx_RefNanny) {
    PyErr_Clear();
    __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny");
    if (!__Pyx_RefNanny)
        Py_FatalError("failed to import 'refnanny' module");
  }
  #endif
  
__Pyx_RefNannySetupContext("PyInit__nvml", 0);
  __Pyx_init_runtime_version();
  if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_mstate->__pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_mstate->__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_mstate->__pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_mstate->__pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
  /*--- Library function declarations ---*/
  /*--- Initialize various global constants etc. ---*/
  if (__Pyx_InitConstants(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
  stringtab_initialized = 1;
  if (__Pyx_InitGlobals() < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
  if (__pyx_module_is_main_cuda__bindings___internal___nvml) {
    if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_name_2, __pyx_mstate_global->__pyx_n_u_main) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
  }
  {
    PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
    if (!PyDict_GetItemString(modules, "cuda.bindings._internal._nvml")) {
      if (unlikely((PyDict_SetItemString(modules, "cuda.bindings._internal._nvml", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
    }
  }
  /*--- Builtin init code ---*/
  if (__Pyx_InitCachedBuiltins(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
  /*--- Constants init code ---*/
  if (__Pyx_InitCachedConstants(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
  if (__Pyx_CreateCodeObjects(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
  /*--- Global type/function init code ---*/
  (void)__Pyx_modinit_global_init_code(__pyx_mstate);
  (void)__Pyx_modinit_variable_export_code(__pyx_mstate);
  if (unlikely((__Pyx_modinit_function_export_code(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
  (void)__Pyx_modinit_type_init_code(__pyx_mstate);
  (void)__Pyx_modinit_type_import_code(__pyx_mstate);
  (void)__Pyx_modinit_variable_import_code(__pyx_mstate);
  (void)__Pyx_modinit_function_import_code(__pyx_mstate);
  /*--- Execution code ---*/

  /* "cuda/bindings/_internal/_nvml.pyx":9
 * from libc.stdint cimport intptr_t, uintptr_t
 * 
 * import threading             # <<<<<<<<<<<<<<
 * 
 * from .utils import FunctionNotFoundError, NotSupportedError
*/
  __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_threading, 0, 0, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error)
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_threading, __pyx_t_2) < (0)) __PYX_ERR(0, 9, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":11
 * import threading
 * 
 * from .utils import FunctionNotFoundError, NotSupportedError             # <<<<<<<<<<<<<<
 * 
 * from cuda.pathfinder import load_nvidia_dynamic_lib
*/
  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_FunctionNotFoundError,__pyx_mstate_global->__pyx_n_u_NotSupportedError};
    __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_utils, __pyx_imported_names, 2, __pyx_mstate_global->__pyx_kp_u_cuda_bindings__internal_utils, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_FunctionNotFoundError,__pyx_mstate_global->__pyx_n_u_NotSupportedError};
    for (__pyx_t_3=0; __pyx_t_3 < 2; __pyx_t_3++) {
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 11, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 11, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":13
 * from .utils import FunctionNotFoundError, NotSupportedError
 * 
 * from cuda.pathfinder import load_nvidia_dynamic_lib             # <<<<<<<<<<<<<<
 * 
 * 
*/
  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_load_nvidia_dynamic_lib};
    __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_cuda_pathfinder, __pyx_imported_names, 1, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_load_nvidia_dynamic_lib};
    __pyx_t_3 = 0; {
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 13, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 13, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":60
 * ###############################################################################
 * 
 * cdef object __symbol_lock = threading.Lock()             # <<<<<<<<<<<<<<
 * cdef bint __py_nvml_init = False
 * 
*/
  __pyx_t_4 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_threading); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 60, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_Lock); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 60, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_7 = 1;
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
    __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __Pyx_XGOTREF(__pyx_v_4cuda_8bindings_9_internal_5_nvml___symbol_lock);
  __Pyx_DECREF_SET(__pyx_v_4cuda_8bindings_9_internal_5_nvml___symbol_lock, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_2);
  __pyx_t_2 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":61
 * 
 * cdef object __symbol_lock = threading.Lock()
 * cdef bint __py_nvml_init = False             # <<<<<<<<<<<<<<
 * 
 * cdef void* __nvmlInit_v2 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___py_nvml_init = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":63
 * cdef bint __py_nvml_init = False
 * 
 * cdef void* __nvmlInit_v2 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlInitWithFlags = NULL
 * cdef void* __nvmlShutdown = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlInit_v2 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":64
 * 
 * cdef void* __nvmlInit_v2 = NULL
 * cdef void* __nvmlInitWithFlags = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlShutdown = NULL
 * cdef void* __nvmlErrorString = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlInitWithFlags = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":65
 * cdef void* __nvmlInit_v2 = NULL
 * cdef void* __nvmlInitWithFlags = NULL
 * cdef void* __nvmlShutdown = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlErrorString = NULL
 * cdef void* __nvmlSystemGetDriverVersion = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlShutdown = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":66
 * cdef void* __nvmlInitWithFlags = NULL
 * cdef void* __nvmlShutdown = NULL
 * cdef void* __nvmlErrorString = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlSystemGetDriverVersion = NULL
 * cdef void* __nvmlSystemGetNVMLVersion = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlErrorString = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":67
 * cdef void* __nvmlShutdown = NULL
 * cdef void* __nvmlErrorString = NULL
 * cdef void* __nvmlSystemGetDriverVersion = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlSystemGetNVMLVersion = NULL
 * cdef void* __nvmlSystemGetCudaDriverVersion = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetDriverVersion = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":68
 * cdef void* __nvmlErrorString = NULL
 * cdef void* __nvmlSystemGetDriverVersion = NULL
 * cdef void* __nvmlSystemGetNVMLVersion = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlSystemGetCudaDriverVersion = NULL
 * cdef void* __nvmlSystemGetCudaDriverVersion_v2 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetNVMLVersion = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":69
 * cdef void* __nvmlSystemGetDriverVersion = NULL
 * cdef void* __nvmlSystemGetNVMLVersion = NULL
 * cdef void* __nvmlSystemGetCudaDriverVersion = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlSystemGetCudaDriverVersion_v2 = NULL
 * cdef void* __nvmlSystemGetProcessName = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetCudaDriverVersion = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":70
 * cdef void* __nvmlSystemGetNVMLVersion = NULL
 * cdef void* __nvmlSystemGetCudaDriverVersion = NULL
 * cdef void* __nvmlSystemGetCudaDriverVersion_v2 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlSystemGetProcessName = NULL
 * cdef void* __nvmlSystemGetHicVersion = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetCudaDriverVersion_v2 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":71
 * cdef void* __nvmlSystemGetCudaDriverVersion = NULL
 * cdef void* __nvmlSystemGetCudaDriverVersion_v2 = NULL
 * cdef void* __nvmlSystemGetProcessName = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlSystemGetHicVersion = NULL
 * cdef void* __nvmlSystemGetTopologyGpuSet = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetProcessName = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":72
 * cdef void* __nvmlSystemGetCudaDriverVersion_v2 = NULL
 * cdef void* __nvmlSystemGetProcessName = NULL
 * cdef void* __nvmlSystemGetHicVersion = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlSystemGetTopologyGpuSet = NULL
 * cdef void* __nvmlSystemGetDriverBranch = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetHicVersion = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":73
 * cdef void* __nvmlSystemGetProcessName = NULL
 * cdef void* __nvmlSystemGetHicVersion = NULL
 * cdef void* __nvmlSystemGetTopologyGpuSet = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlSystemGetDriverBranch = NULL
 * cdef void* __nvmlUnitGetCount = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetTopologyGpuSet = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":74
 * cdef void* __nvmlSystemGetHicVersion = NULL
 * cdef void* __nvmlSystemGetTopologyGpuSet = NULL
 * cdef void* __nvmlSystemGetDriverBranch = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlUnitGetCount = NULL
 * cdef void* __nvmlUnitGetHandleByIndex = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetDriverBranch = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":75
 * cdef void* __nvmlSystemGetTopologyGpuSet = NULL
 * cdef void* __nvmlSystemGetDriverBranch = NULL
 * cdef void* __nvmlUnitGetCount = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlUnitGetHandleByIndex = NULL
 * cdef void* __nvmlUnitGetUnitInfo = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetCount = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":76
 * cdef void* __nvmlSystemGetDriverBranch = NULL
 * cdef void* __nvmlUnitGetCount = NULL
 * cdef void* __nvmlUnitGetHandleByIndex = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlUnitGetUnitInfo = NULL
 * cdef void* __nvmlUnitGetLedState = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetHandleByIndex = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":77
 * cdef void* __nvmlUnitGetCount = NULL
 * cdef void* __nvmlUnitGetHandleByIndex = NULL
 * cdef void* __nvmlUnitGetUnitInfo = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlUnitGetLedState = NULL
 * cdef void* __nvmlUnitGetPsuInfo = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetUnitInfo = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":78
 * cdef void* __nvmlUnitGetHandleByIndex = NULL
 * cdef void* __nvmlUnitGetUnitInfo = NULL
 * cdef void* __nvmlUnitGetLedState = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlUnitGetPsuInfo = NULL
 * cdef void* __nvmlUnitGetTemperature = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetLedState = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":79
 * cdef void* __nvmlUnitGetUnitInfo = NULL
 * cdef void* __nvmlUnitGetLedState = NULL
 * cdef void* __nvmlUnitGetPsuInfo = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlUnitGetTemperature = NULL
 * cdef void* __nvmlUnitGetFanSpeedInfo = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetPsuInfo = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":80
 * cdef void* __nvmlUnitGetLedState = NULL
 * cdef void* __nvmlUnitGetPsuInfo = NULL
 * cdef void* __nvmlUnitGetTemperature = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlUnitGetFanSpeedInfo = NULL
 * cdef void* __nvmlUnitGetDevices = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetTemperature = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":81
 * cdef void* __nvmlUnitGetPsuInfo = NULL
 * cdef void* __nvmlUnitGetTemperature = NULL
 * cdef void* __nvmlUnitGetFanSpeedInfo = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlUnitGetDevices = NULL
 * cdef void* __nvmlDeviceGetCount_v2 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetFanSpeedInfo = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":82
 * cdef void* __nvmlUnitGetTemperature = NULL
 * cdef void* __nvmlUnitGetFanSpeedInfo = NULL
 * cdef void* __nvmlUnitGetDevices = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetCount_v2 = NULL
 * cdef void* __nvmlDeviceGetAttributes_v2 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitGetDevices = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":83
 * cdef void* __nvmlUnitGetFanSpeedInfo = NULL
 * cdef void* __nvmlUnitGetDevices = NULL
 * cdef void* __nvmlDeviceGetCount_v2 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetAttributes_v2 = NULL
 * cdef void* __nvmlDeviceGetHandleByIndex_v2 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCount_v2 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":84
 * cdef void* __nvmlUnitGetDevices = NULL
 * cdef void* __nvmlDeviceGetCount_v2 = NULL
 * cdef void* __nvmlDeviceGetAttributes_v2 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetHandleByIndex_v2 = NULL
 * cdef void* __nvmlDeviceGetHandleBySerial = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAttributes_v2 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":85
 * cdef void* __nvmlDeviceGetCount_v2 = NULL
 * cdef void* __nvmlDeviceGetAttributes_v2 = NULL
 * cdef void* __nvmlDeviceGetHandleByIndex_v2 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetHandleBySerial = NULL
 * cdef void* __nvmlDeviceGetHandleByUUID = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByIndex_v2 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":86
 * cdef void* __nvmlDeviceGetAttributes_v2 = NULL
 * cdef void* __nvmlDeviceGetHandleByIndex_v2 = NULL
 * cdef void* __nvmlDeviceGetHandleBySerial = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetHandleByUUID = NULL
 * cdef void* __nvmlDeviceGetHandleByUUIDV = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleBySerial = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":87
 * cdef void* __nvmlDeviceGetHandleByIndex_v2 = NULL
 * cdef void* __nvmlDeviceGetHandleBySerial = NULL
 * cdef void* __nvmlDeviceGetHandleByUUID = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetHandleByUUIDV = NULL
 * cdef void* __nvmlDeviceGetHandleByPciBusId_v2 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByUUID = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":88
 * cdef void* __nvmlDeviceGetHandleBySerial = NULL
 * cdef void* __nvmlDeviceGetHandleByUUID = NULL
 * cdef void* __nvmlDeviceGetHandleByUUIDV = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetHandleByPciBusId_v2 = NULL
 * cdef void* __nvmlDeviceGetName = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByUUIDV = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":89
 * cdef void* __nvmlDeviceGetHandleByUUID = NULL
 * cdef void* __nvmlDeviceGetHandleByUUIDV = NULL
 * cdef void* __nvmlDeviceGetHandleByPciBusId_v2 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetName = NULL
 * cdef void* __nvmlDeviceGetBrand = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHandleByPciBusId_v2 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":90
 * cdef void* __nvmlDeviceGetHandleByUUIDV = NULL
 * cdef void* __nvmlDeviceGetHandleByPciBusId_v2 = NULL
 * cdef void* __nvmlDeviceGetName = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetBrand = NULL
 * cdef void* __nvmlDeviceGetIndex = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetName = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":91
 * cdef void* __nvmlDeviceGetHandleByPciBusId_v2 = NULL
 * cdef void* __nvmlDeviceGetName = NULL
 * cdef void* __nvmlDeviceGetBrand = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetIndex = NULL
 * cdef void* __nvmlDeviceGetSerial = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBrand = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":92
 * cdef void* __nvmlDeviceGetName = NULL
 * cdef void* __nvmlDeviceGetBrand = NULL
 * cdef void* __nvmlDeviceGetIndex = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetSerial = NULL
 * cdef void* __nvmlDeviceGetModuleId = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetIndex = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":93
 * cdef void* __nvmlDeviceGetBrand = NULL
 * cdef void* __nvmlDeviceGetIndex = NULL
 * cdef void* __nvmlDeviceGetSerial = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetModuleId = NULL
 * cdef void* __nvmlDeviceGetC2cModeInfoV = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSerial = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":94
 * cdef void* __nvmlDeviceGetIndex = NULL
 * cdef void* __nvmlDeviceGetSerial = NULL
 * cdef void* __nvmlDeviceGetModuleId = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetC2cModeInfoV = NULL
 * cdef void* __nvmlDeviceGetMemoryAffinity = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetModuleId = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":95
 * cdef void* __nvmlDeviceGetSerial = NULL
 * cdef void* __nvmlDeviceGetModuleId = NULL
 * cdef void* __nvmlDeviceGetC2cModeInfoV = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetMemoryAffinity = NULL
 * cdef void* __nvmlDeviceGetCpuAffinityWithinScope = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetC2cModeInfoV = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":96
 * cdef void* __nvmlDeviceGetModuleId = NULL
 * cdef void* __nvmlDeviceGetC2cModeInfoV = NULL
 * cdef void* __nvmlDeviceGetMemoryAffinity = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetCpuAffinityWithinScope = NULL
 * cdef void* __nvmlDeviceGetCpuAffinity = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryAffinity = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":97
 * cdef void* __nvmlDeviceGetC2cModeInfoV = NULL
 * cdef void* __nvmlDeviceGetMemoryAffinity = NULL
 * cdef void* __nvmlDeviceGetCpuAffinityWithinScope = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetCpuAffinity = NULL
 * cdef void* __nvmlDeviceSetCpuAffinity = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCpuAffinityWithinScope = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":98
 * cdef void* __nvmlDeviceGetMemoryAffinity = NULL
 * cdef void* __nvmlDeviceGetCpuAffinityWithinScope = NULL
 * cdef void* __nvmlDeviceGetCpuAffinity = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetCpuAffinity = NULL
 * cdef void* __nvmlDeviceClearCpuAffinity = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCpuAffinity = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":99
 * cdef void* __nvmlDeviceGetCpuAffinityWithinScope = NULL
 * cdef void* __nvmlDeviceGetCpuAffinity = NULL
 * cdef void* __nvmlDeviceSetCpuAffinity = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceClearCpuAffinity = NULL
 * cdef void* __nvmlDeviceGetNumaNodeId = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetCpuAffinity = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":100
 * cdef void* __nvmlDeviceGetCpuAffinity = NULL
 * cdef void* __nvmlDeviceSetCpuAffinity = NULL
 * cdef void* __nvmlDeviceClearCpuAffinity = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetNumaNodeId = NULL
 * cdef void* __nvmlDeviceGetTopologyCommonAncestor = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearCpuAffinity = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":101
 * cdef void* __nvmlDeviceSetCpuAffinity = NULL
 * cdef void* __nvmlDeviceClearCpuAffinity = NULL
 * cdef void* __nvmlDeviceGetNumaNodeId = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetTopologyCommonAncestor = NULL
 * cdef void* __nvmlDeviceGetTopologyNearestGpus = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNumaNodeId = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":102
 * cdef void* __nvmlDeviceClearCpuAffinity = NULL
 * cdef void* __nvmlDeviceGetNumaNodeId = NULL
 * cdef void* __nvmlDeviceGetTopologyCommonAncestor = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetTopologyNearestGpus = NULL
 * cdef void* __nvmlDeviceGetP2PStatus = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTopologyCommonAncestor = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":103
 * cdef void* __nvmlDeviceGetNumaNodeId = NULL
 * cdef void* __nvmlDeviceGetTopologyCommonAncestor = NULL
 * cdef void* __nvmlDeviceGetTopologyNearestGpus = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetP2PStatus = NULL
 * cdef void* __nvmlDeviceGetUUID = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTopologyNearestGpus = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":104
 * cdef void* __nvmlDeviceGetTopologyCommonAncestor = NULL
 * cdef void* __nvmlDeviceGetTopologyNearestGpus = NULL
 * cdef void* __nvmlDeviceGetP2PStatus = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetUUID = NULL
 * cdef void* __nvmlDeviceGetMinorNumber = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetP2PStatus = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":105
 * cdef void* __nvmlDeviceGetTopologyNearestGpus = NULL
 * cdef void* __nvmlDeviceGetP2PStatus = NULL
 * cdef void* __nvmlDeviceGetUUID = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetMinorNumber = NULL
 * cdef void* __nvmlDeviceGetBoardPartNumber = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetUUID = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":106
 * cdef void* __nvmlDeviceGetP2PStatus = NULL
 * cdef void* __nvmlDeviceGetUUID = NULL
 * cdef void* __nvmlDeviceGetMinorNumber = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetBoardPartNumber = NULL
 * cdef void* __nvmlDeviceGetInforomVersion = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMinorNumber = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":107
 * cdef void* __nvmlDeviceGetUUID = NULL
 * cdef void* __nvmlDeviceGetMinorNumber = NULL
 * cdef void* __nvmlDeviceGetBoardPartNumber = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetInforomVersion = NULL
 * cdef void* __nvmlDeviceGetInforomImageVersion = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBoardPartNumber = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":108
 * cdef void* __nvmlDeviceGetMinorNumber = NULL
 * cdef void* __nvmlDeviceGetBoardPartNumber = NULL
 * cdef void* __nvmlDeviceGetInforomVersion = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetInforomImageVersion = NULL
 * cdef void* __nvmlDeviceGetInforomConfigurationChecksum = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetInforomVersion = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":109
 * cdef void* __nvmlDeviceGetBoardPartNumber = NULL
 * cdef void* __nvmlDeviceGetInforomVersion = NULL
 * cdef void* __nvmlDeviceGetInforomImageVersion = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetInforomConfigurationChecksum = NULL
 * cdef void* __nvmlDeviceValidateInforom = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetInforomImageVersion = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":110
 * cdef void* __nvmlDeviceGetInforomVersion = NULL
 * cdef void* __nvmlDeviceGetInforomImageVersion = NULL
 * cdef void* __nvmlDeviceGetInforomConfigurationChecksum = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceValidateInforom = NULL
 * cdef void* __nvmlDeviceGetLastBBXFlushTime = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetInforomConfigurationChecksum = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":111
 * cdef void* __nvmlDeviceGetInforomImageVersion = NULL
 * cdef void* __nvmlDeviceGetInforomConfigurationChecksum = NULL
 * cdef void* __nvmlDeviceValidateInforom = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetLastBBXFlushTime = NULL
 * cdef void* __nvmlDeviceGetDisplayMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceValidateInforom = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":112
 * cdef void* __nvmlDeviceGetInforomConfigurationChecksum = NULL
 * cdef void* __nvmlDeviceValidateInforom = NULL
 * cdef void* __nvmlDeviceGetLastBBXFlushTime = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetDisplayMode = NULL
 * cdef void* __nvmlDeviceGetDisplayActive = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetLastBBXFlushTime = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":113
 * cdef void* __nvmlDeviceValidateInforom = NULL
 * cdef void* __nvmlDeviceGetLastBBXFlushTime = NULL
 * cdef void* __nvmlDeviceGetDisplayMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetDisplayActive = NULL
 * cdef void* __nvmlDeviceGetPersistenceMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDisplayMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":114
 * cdef void* __nvmlDeviceGetLastBBXFlushTime = NULL
 * cdef void* __nvmlDeviceGetDisplayMode = NULL
 * cdef void* __nvmlDeviceGetDisplayActive = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetPersistenceMode = NULL
 * cdef void* __nvmlDeviceGetPciInfoExt = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDisplayActive = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":115
 * cdef void* __nvmlDeviceGetDisplayMode = NULL
 * cdef void* __nvmlDeviceGetDisplayActive = NULL
 * cdef void* __nvmlDeviceGetPersistenceMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetPciInfoExt = NULL
 * cdef void* __nvmlDeviceGetPciInfo_v3 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPersistenceMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":116
 * cdef void* __nvmlDeviceGetDisplayActive = NULL
 * cdef void* __nvmlDeviceGetPersistenceMode = NULL
 * cdef void* __nvmlDeviceGetPciInfoExt = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetPciInfo_v3 = NULL
 * cdef void* __nvmlDeviceGetMaxPcieLinkGeneration = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPciInfoExt = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":117
 * cdef void* __nvmlDeviceGetPersistenceMode = NULL
 * cdef void* __nvmlDeviceGetPciInfoExt = NULL
 * cdef void* __nvmlDeviceGetPciInfo_v3 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetMaxPcieLinkGeneration = NULL
 * cdef void* __nvmlDeviceGetGpuMaxPcieLinkGeneration = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPciInfo_v3 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":118
 * cdef void* __nvmlDeviceGetPciInfoExt = NULL
 * cdef void* __nvmlDeviceGetPciInfo_v3 = NULL
 * cdef void* __nvmlDeviceGetMaxPcieLinkGeneration = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetGpuMaxPcieLinkGeneration = NULL
 * cdef void* __nvmlDeviceGetMaxPcieLinkWidth = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxPcieLinkGeneration = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":119
 * cdef void* __nvmlDeviceGetPciInfo_v3 = NULL
 * cdef void* __nvmlDeviceGetMaxPcieLinkGeneration = NULL
 * cdef void* __nvmlDeviceGetGpuMaxPcieLinkGeneration = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetMaxPcieLinkWidth = NULL
 * cdef void* __nvmlDeviceGetCurrPcieLinkGeneration = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuMaxPcieLinkGeneration = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":120
 * cdef void* __nvmlDeviceGetMaxPcieLinkGeneration = NULL
 * cdef void* __nvmlDeviceGetGpuMaxPcieLinkGeneration = NULL
 * cdef void* __nvmlDeviceGetMaxPcieLinkWidth = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetCurrPcieLinkGeneration = NULL
 * cdef void* __nvmlDeviceGetCurrPcieLinkWidth = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxPcieLinkWidth = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":121
 * cdef void* __nvmlDeviceGetGpuMaxPcieLinkGeneration = NULL
 * cdef void* __nvmlDeviceGetMaxPcieLinkWidth = NULL
 * cdef void* __nvmlDeviceGetCurrPcieLinkGeneration = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetCurrPcieLinkWidth = NULL
 * cdef void* __nvmlDeviceGetPcieThroughput = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrPcieLinkGeneration = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":122
 * cdef void* __nvmlDeviceGetMaxPcieLinkWidth = NULL
 * cdef void* __nvmlDeviceGetCurrPcieLinkGeneration = NULL
 * cdef void* __nvmlDeviceGetCurrPcieLinkWidth = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetPcieThroughput = NULL
 * cdef void* __nvmlDeviceGetPcieReplayCounter = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrPcieLinkWidth = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":123
 * cdef void* __nvmlDeviceGetCurrPcieLinkGeneration = NULL
 * cdef void* __nvmlDeviceGetCurrPcieLinkWidth = NULL
 * cdef void* __nvmlDeviceGetPcieThroughput = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetPcieReplayCounter = NULL
 * cdef void* __nvmlDeviceGetClockInfo = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieThroughput = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":124
 * cdef void* __nvmlDeviceGetCurrPcieLinkWidth = NULL
 * cdef void* __nvmlDeviceGetPcieThroughput = NULL
 * cdef void* __nvmlDeviceGetPcieReplayCounter = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetClockInfo = NULL
 * cdef void* __nvmlDeviceGetMaxClockInfo = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieReplayCounter = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":125
 * cdef void* __nvmlDeviceGetPcieThroughput = NULL
 * cdef void* __nvmlDeviceGetPcieReplayCounter = NULL
 * cdef void* __nvmlDeviceGetClockInfo = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetMaxClockInfo = NULL
 * cdef void* __nvmlDeviceGetGpcClkVfOffset = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClockInfo = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":126
 * cdef void* __nvmlDeviceGetPcieReplayCounter = NULL
 * cdef void* __nvmlDeviceGetClockInfo = NULL
 * cdef void* __nvmlDeviceGetMaxClockInfo = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetGpcClkVfOffset = NULL
 * cdef void* __nvmlDeviceGetClock = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxClockInfo = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":127
 * cdef void* __nvmlDeviceGetClockInfo = NULL
 * cdef void* __nvmlDeviceGetMaxClockInfo = NULL
 * cdef void* __nvmlDeviceGetGpcClkVfOffset = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetClock = NULL
 * cdef void* __nvmlDeviceGetMaxCustomerBoostClock = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpcClkVfOffset = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":128
 * cdef void* __nvmlDeviceGetMaxClockInfo = NULL
 * cdef void* __nvmlDeviceGetGpcClkVfOffset = NULL
 * cdef void* __nvmlDeviceGetClock = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetMaxCustomerBoostClock = NULL
 * cdef void* __nvmlDeviceGetSupportedMemoryClocks = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClock = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":129
 * cdef void* __nvmlDeviceGetGpcClkVfOffset = NULL
 * cdef void* __nvmlDeviceGetClock = NULL
 * cdef void* __nvmlDeviceGetMaxCustomerBoostClock = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetSupportedMemoryClocks = NULL
 * cdef void* __nvmlDeviceGetSupportedGraphicsClocks = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxCustomerBoostClock = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":130
 * cdef void* __nvmlDeviceGetClock = NULL
 * cdef void* __nvmlDeviceGetMaxCustomerBoostClock = NULL
 * cdef void* __nvmlDeviceGetSupportedMemoryClocks = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetSupportedGraphicsClocks = NULL
 * cdef void* __nvmlDeviceGetAutoBoostedClocksEnabled = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedMemoryClocks = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":131
 * cdef void* __nvmlDeviceGetMaxCustomerBoostClock = NULL
 * cdef void* __nvmlDeviceGetSupportedMemoryClocks = NULL
 * cdef void* __nvmlDeviceGetSupportedGraphicsClocks = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetAutoBoostedClocksEnabled = NULL
 * cdef void* __nvmlDeviceGetFanSpeed = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedGraphicsClocks = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":132
 * cdef void* __nvmlDeviceGetSupportedMemoryClocks = NULL
 * cdef void* __nvmlDeviceGetSupportedGraphicsClocks = NULL
 * cdef void* __nvmlDeviceGetAutoBoostedClocksEnabled = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetFanSpeed = NULL
 * cdef void* __nvmlDeviceGetFanSpeed_v2 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAutoBoostedClocksEnabled = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":133
 * cdef void* __nvmlDeviceGetSupportedGraphicsClocks = NULL
 * cdef void* __nvmlDeviceGetAutoBoostedClocksEnabled = NULL
 * cdef void* __nvmlDeviceGetFanSpeed = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetFanSpeed_v2 = NULL
 * cdef void* __nvmlDeviceGetFanSpeedRPM = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanSpeed = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":134
 * cdef void* __nvmlDeviceGetAutoBoostedClocksEnabled = NULL
 * cdef void* __nvmlDeviceGetFanSpeed = NULL
 * cdef void* __nvmlDeviceGetFanSpeed_v2 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetFanSpeedRPM = NULL
 * cdef void* __nvmlDeviceGetTargetFanSpeed = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanSpeed_v2 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":135
 * cdef void* __nvmlDeviceGetFanSpeed = NULL
 * cdef void* __nvmlDeviceGetFanSpeed_v2 = NULL
 * cdef void* __nvmlDeviceGetFanSpeedRPM = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetTargetFanSpeed = NULL
 * cdef void* __nvmlDeviceGetMinMaxFanSpeed = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanSpeedRPM = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":136
 * cdef void* __nvmlDeviceGetFanSpeed_v2 = NULL
 * cdef void* __nvmlDeviceGetFanSpeedRPM = NULL
 * cdef void* __nvmlDeviceGetTargetFanSpeed = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetMinMaxFanSpeed = NULL
 * cdef void* __nvmlDeviceGetFanControlPolicy_v2 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTargetFanSpeed = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":137
 * cdef void* __nvmlDeviceGetFanSpeedRPM = NULL
 * cdef void* __nvmlDeviceGetTargetFanSpeed = NULL
 * cdef void* __nvmlDeviceGetMinMaxFanSpeed = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetFanControlPolicy_v2 = NULL
 * cdef void* __nvmlDeviceGetNumFans = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMinMaxFanSpeed = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":138
 * cdef void* __nvmlDeviceGetTargetFanSpeed = NULL
 * cdef void* __nvmlDeviceGetMinMaxFanSpeed = NULL
 * cdef void* __nvmlDeviceGetFanControlPolicy_v2 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetNumFans = NULL
 * cdef void* __nvmlDeviceGetCoolerInfo = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFanControlPolicy_v2 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":139
 * cdef void* __nvmlDeviceGetMinMaxFanSpeed = NULL
 * cdef void* __nvmlDeviceGetFanControlPolicy_v2 = NULL
 * cdef void* __nvmlDeviceGetNumFans = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetCoolerInfo = NULL
 * cdef void* __nvmlDeviceGetTemperatureV = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNumFans = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":140
 * cdef void* __nvmlDeviceGetFanControlPolicy_v2 = NULL
 * cdef void* __nvmlDeviceGetNumFans = NULL
 * cdef void* __nvmlDeviceGetCoolerInfo = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetTemperatureV = NULL
 * cdef void* __nvmlDeviceGetTemperatureThreshold = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCoolerInfo = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":141
 * cdef void* __nvmlDeviceGetNumFans = NULL
 * cdef void* __nvmlDeviceGetCoolerInfo = NULL
 * cdef void* __nvmlDeviceGetTemperatureV = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetTemperatureThreshold = NULL
 * cdef void* __nvmlDeviceGetMarginTemperature = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTemperatureV = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":142
 * cdef void* __nvmlDeviceGetCoolerInfo = NULL
 * cdef void* __nvmlDeviceGetTemperatureV = NULL
 * cdef void* __nvmlDeviceGetTemperatureThreshold = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetMarginTemperature = NULL
 * cdef void* __nvmlDeviceGetThermalSettings = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTemperatureThreshold = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":143
 * cdef void* __nvmlDeviceGetTemperatureV = NULL
 * cdef void* __nvmlDeviceGetTemperatureThreshold = NULL
 * cdef void* __nvmlDeviceGetMarginTemperature = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetThermalSettings = NULL
 * cdef void* __nvmlDeviceGetPerformanceState = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMarginTemperature = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":144
 * cdef void* __nvmlDeviceGetTemperatureThreshold = NULL
 * cdef void* __nvmlDeviceGetMarginTemperature = NULL
 * cdef void* __nvmlDeviceGetThermalSettings = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetPerformanceState = NULL
 * cdef void* __nvmlDeviceGetCurrentClocksEventReasons = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetThermalSettings = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":145
 * cdef void* __nvmlDeviceGetMarginTemperature = NULL
 * cdef void* __nvmlDeviceGetThermalSettings = NULL
 * cdef void* __nvmlDeviceGetPerformanceState = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetCurrentClocksEventReasons = NULL
 * cdef void* __nvmlDeviceGetSupportedClocksEventReasons = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPerformanceState = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":146
 * cdef void* __nvmlDeviceGetThermalSettings = NULL
 * cdef void* __nvmlDeviceGetPerformanceState = NULL
 * cdef void* __nvmlDeviceGetCurrentClocksEventReasons = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetSupportedClocksEventReasons = NULL
 * cdef void* __nvmlDeviceGetPowerState = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrentClocksEventReasons = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":147
 * cdef void* __nvmlDeviceGetPerformanceState = NULL
 * cdef void* __nvmlDeviceGetCurrentClocksEventReasons = NULL
 * cdef void* __nvmlDeviceGetSupportedClocksEventReasons = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetPowerState = NULL
 * cdef void* __nvmlDeviceGetDynamicPstatesInfo = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedClocksEventReasons = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":148
 * cdef void* __nvmlDeviceGetCurrentClocksEventReasons = NULL
 * cdef void* __nvmlDeviceGetSupportedClocksEventReasons = NULL
 * cdef void* __nvmlDeviceGetPowerState = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetDynamicPstatesInfo = NULL
 * cdef void* __nvmlDeviceGetMemClkVfOffset = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerState = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":149
 * cdef void* __nvmlDeviceGetSupportedClocksEventReasons = NULL
 * cdef void* __nvmlDeviceGetPowerState = NULL
 * cdef void* __nvmlDeviceGetDynamicPstatesInfo = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetMemClkVfOffset = NULL
 * cdef void* __nvmlDeviceGetMinMaxClockOfPState = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDynamicPstatesInfo = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":150
 * cdef void* __nvmlDeviceGetPowerState = NULL
 * cdef void* __nvmlDeviceGetDynamicPstatesInfo = NULL
 * cdef void* __nvmlDeviceGetMemClkVfOffset = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetMinMaxClockOfPState = NULL
 * cdef void* __nvmlDeviceGetSupportedPerformanceStates = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemClkVfOffset = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":151
 * cdef void* __nvmlDeviceGetDynamicPstatesInfo = NULL
 * cdef void* __nvmlDeviceGetMemClkVfOffset = NULL
 * cdef void* __nvmlDeviceGetMinMaxClockOfPState = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetSupportedPerformanceStates = NULL
 * cdef void* __nvmlDeviceGetGpcClkMinMaxVfOffset = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMinMaxClockOfPState = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":152
 * cdef void* __nvmlDeviceGetMemClkVfOffset = NULL
 * cdef void* __nvmlDeviceGetMinMaxClockOfPState = NULL
 * cdef void* __nvmlDeviceGetSupportedPerformanceStates = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetGpcClkMinMaxVfOffset = NULL
 * cdef void* __nvmlDeviceGetMemClkMinMaxVfOffset = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedPerformanceStates = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":153
 * cdef void* __nvmlDeviceGetMinMaxClockOfPState = NULL
 * cdef void* __nvmlDeviceGetSupportedPerformanceStates = NULL
 * cdef void* __nvmlDeviceGetGpcClkMinMaxVfOffset = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetMemClkMinMaxVfOffset = NULL
 * cdef void* __nvmlDeviceGetClockOffsets = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpcClkMinMaxVfOffset = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":154
 * cdef void* __nvmlDeviceGetSupportedPerformanceStates = NULL
 * cdef void* __nvmlDeviceGetGpcClkMinMaxVfOffset = NULL
 * cdef void* __nvmlDeviceGetMemClkMinMaxVfOffset = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetClockOffsets = NULL
 * cdef void* __nvmlDeviceSetClockOffsets = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemClkMinMaxVfOffset = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":155
 * cdef void* __nvmlDeviceGetGpcClkMinMaxVfOffset = NULL
 * cdef void* __nvmlDeviceGetMemClkMinMaxVfOffset = NULL
 * cdef void* __nvmlDeviceGetClockOffsets = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetClockOffsets = NULL
 * cdef void* __nvmlDeviceGetPerformanceModes = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClockOffsets = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":156
 * cdef void* __nvmlDeviceGetMemClkMinMaxVfOffset = NULL
 * cdef void* __nvmlDeviceGetClockOffsets = NULL
 * cdef void* __nvmlDeviceSetClockOffsets = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetPerformanceModes = NULL
 * cdef void* __nvmlDeviceGetCurrentClockFreqs = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetClockOffsets = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":157
 * cdef void* __nvmlDeviceGetClockOffsets = NULL
 * cdef void* __nvmlDeviceSetClockOffsets = NULL
 * cdef void* __nvmlDeviceGetPerformanceModes = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetCurrentClockFreqs = NULL
 * cdef void* __nvmlDeviceGetPowerManagementLimit = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPerformanceModes = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":158
 * cdef void* __nvmlDeviceSetClockOffsets = NULL
 * cdef void* __nvmlDeviceGetPerformanceModes = NULL
 * cdef void* __nvmlDeviceGetCurrentClockFreqs = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetPowerManagementLimit = NULL
 * cdef void* __nvmlDeviceGetPowerManagementLimitConstraints = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCurrentClockFreqs = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":159
 * cdef void* __nvmlDeviceGetPerformanceModes = NULL
 * cdef void* __nvmlDeviceGetCurrentClockFreqs = NULL
 * cdef void* __nvmlDeviceGetPowerManagementLimit = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetPowerManagementLimitConstraints = NULL
 * cdef void* __nvmlDeviceGetPowerManagementDefaultLimit = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerManagementLimit = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":160
 * cdef void* __nvmlDeviceGetCurrentClockFreqs = NULL
 * cdef void* __nvmlDeviceGetPowerManagementLimit = NULL
 * cdef void* __nvmlDeviceGetPowerManagementLimitConstraints = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetPowerManagementDefaultLimit = NULL
 * cdef void* __nvmlDeviceGetPowerUsage = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerManagementLimitConstraints = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":161
 * cdef void* __nvmlDeviceGetPowerManagementLimit = NULL
 * cdef void* __nvmlDeviceGetPowerManagementLimitConstraints = NULL
 * cdef void* __nvmlDeviceGetPowerManagementDefaultLimit = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetPowerUsage = NULL
 * cdef void* __nvmlDeviceGetTotalEnergyConsumption = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerManagementDefaultLimit = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":162
 * cdef void* __nvmlDeviceGetPowerManagementLimitConstraints = NULL
 * cdef void* __nvmlDeviceGetPowerManagementDefaultLimit = NULL
 * cdef void* __nvmlDeviceGetPowerUsage = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetTotalEnergyConsumption = NULL
 * cdef void* __nvmlDeviceGetEnforcedPowerLimit = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerUsage = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":163
 * cdef void* __nvmlDeviceGetPowerManagementDefaultLimit = NULL
 * cdef void* __nvmlDeviceGetPowerUsage = NULL
 * cdef void* __nvmlDeviceGetTotalEnergyConsumption = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetEnforcedPowerLimit = NULL
 * cdef void* __nvmlDeviceGetGpuOperationMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTotalEnergyConsumption = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":164
 * cdef void* __nvmlDeviceGetPowerUsage = NULL
 * cdef void* __nvmlDeviceGetTotalEnergyConsumption = NULL
 * cdef void* __nvmlDeviceGetEnforcedPowerLimit = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetGpuOperationMode = NULL
 * cdef void* __nvmlDeviceGetMemoryInfo_v2 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEnforcedPowerLimit = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":165
 * cdef void* __nvmlDeviceGetTotalEnergyConsumption = NULL
 * cdef void* __nvmlDeviceGetEnforcedPowerLimit = NULL
 * cdef void* __nvmlDeviceGetGpuOperationMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetMemoryInfo_v2 = NULL
 * cdef void* __nvmlDeviceGetComputeMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuOperationMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":166
 * cdef void* __nvmlDeviceGetEnforcedPowerLimit = NULL
 * cdef void* __nvmlDeviceGetGpuOperationMode = NULL
 * cdef void* __nvmlDeviceGetMemoryInfo_v2 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetComputeMode = NULL
 * cdef void* __nvmlDeviceGetCudaComputeCapability = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryInfo_v2 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":167
 * cdef void* __nvmlDeviceGetGpuOperationMode = NULL
 * cdef void* __nvmlDeviceGetMemoryInfo_v2 = NULL
 * cdef void* __nvmlDeviceGetComputeMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetCudaComputeCapability = NULL
 * cdef void* __nvmlDeviceGetDramEncryptionMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetComputeMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":168
 * cdef void* __nvmlDeviceGetMemoryInfo_v2 = NULL
 * cdef void* __nvmlDeviceGetComputeMode = NULL
 * cdef void* __nvmlDeviceGetCudaComputeCapability = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetDramEncryptionMode = NULL
 * cdef void* __nvmlDeviceSetDramEncryptionMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCudaComputeCapability = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":169
 * cdef void* __nvmlDeviceGetComputeMode = NULL
 * cdef void* __nvmlDeviceGetCudaComputeCapability = NULL
 * cdef void* __nvmlDeviceGetDramEncryptionMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetDramEncryptionMode = NULL
 * cdef void* __nvmlDeviceGetEccMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDramEncryptionMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":170
 * cdef void* __nvmlDeviceGetCudaComputeCapability = NULL
 * cdef void* __nvmlDeviceGetDramEncryptionMode = NULL
 * cdef void* __nvmlDeviceSetDramEncryptionMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetEccMode = NULL
 * cdef void* __nvmlDeviceGetDefaultEccMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDramEncryptionMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":171
 * cdef void* __nvmlDeviceGetDramEncryptionMode = NULL
 * cdef void* __nvmlDeviceSetDramEncryptionMode = NULL
 * cdef void* __nvmlDeviceGetEccMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetDefaultEccMode = NULL
 * cdef void* __nvmlDeviceGetBoardId = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEccMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":172
 * cdef void* __nvmlDeviceSetDramEncryptionMode = NULL
 * cdef void* __nvmlDeviceGetEccMode = NULL
 * cdef void* __nvmlDeviceGetDefaultEccMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetBoardId = NULL
 * cdef void* __nvmlDeviceGetMultiGpuBoard = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDefaultEccMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":173
 * cdef void* __nvmlDeviceGetEccMode = NULL
 * cdef void* __nvmlDeviceGetDefaultEccMode = NULL
 * cdef void* __nvmlDeviceGetBoardId = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetMultiGpuBoard = NULL
 * cdef void* __nvmlDeviceGetTotalEccErrors = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBoardId = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":174
 * cdef void* __nvmlDeviceGetDefaultEccMode = NULL
 * cdef void* __nvmlDeviceGetBoardId = NULL
 * cdef void* __nvmlDeviceGetMultiGpuBoard = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetTotalEccErrors = NULL
 * cdef void* __nvmlDeviceGetMemoryErrorCounter = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMultiGpuBoard = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":175
 * cdef void* __nvmlDeviceGetBoardId = NULL
 * cdef void* __nvmlDeviceGetMultiGpuBoard = NULL
 * cdef void* __nvmlDeviceGetTotalEccErrors = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetMemoryErrorCounter = NULL
 * cdef void* __nvmlDeviceGetUtilizationRates = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetTotalEccErrors = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":176
 * cdef void* __nvmlDeviceGetMultiGpuBoard = NULL
 * cdef void* __nvmlDeviceGetTotalEccErrors = NULL
 * cdef void* __nvmlDeviceGetMemoryErrorCounter = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetUtilizationRates = NULL
 * cdef void* __nvmlDeviceGetEncoderUtilization = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryErrorCounter = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":177
 * cdef void* __nvmlDeviceGetTotalEccErrors = NULL
 * cdef void* __nvmlDeviceGetMemoryErrorCounter = NULL
 * cdef void* __nvmlDeviceGetUtilizationRates = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetEncoderUtilization = NULL
 * cdef void* __nvmlDeviceGetEncoderCapacity = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetUtilizationRates = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":178
 * cdef void* __nvmlDeviceGetMemoryErrorCounter = NULL
 * cdef void* __nvmlDeviceGetUtilizationRates = NULL
 * cdef void* __nvmlDeviceGetEncoderUtilization = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetEncoderCapacity = NULL
 * cdef void* __nvmlDeviceGetEncoderStats = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderUtilization = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":179
 * cdef void* __nvmlDeviceGetUtilizationRates = NULL
 * cdef void* __nvmlDeviceGetEncoderUtilization = NULL
 * cdef void* __nvmlDeviceGetEncoderCapacity = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetEncoderStats = NULL
 * cdef void* __nvmlDeviceGetEncoderSessions = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderCapacity = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":180
 * cdef void* __nvmlDeviceGetEncoderUtilization = NULL
 * cdef void* __nvmlDeviceGetEncoderCapacity = NULL
 * cdef void* __nvmlDeviceGetEncoderStats = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetEncoderSessions = NULL
 * cdef void* __nvmlDeviceGetDecoderUtilization = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderStats = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":181
 * cdef void* __nvmlDeviceGetEncoderCapacity = NULL
 * cdef void* __nvmlDeviceGetEncoderStats = NULL
 * cdef void* __nvmlDeviceGetEncoderSessions = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetDecoderUtilization = NULL
 * cdef void* __nvmlDeviceGetJpgUtilization = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetEncoderSessions = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":182
 * cdef void* __nvmlDeviceGetEncoderStats = NULL
 * cdef void* __nvmlDeviceGetEncoderSessions = NULL
 * cdef void* __nvmlDeviceGetDecoderUtilization = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetJpgUtilization = NULL
 * cdef void* __nvmlDeviceGetOfaUtilization = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDecoderUtilization = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":183
 * cdef void* __nvmlDeviceGetEncoderSessions = NULL
 * cdef void* __nvmlDeviceGetDecoderUtilization = NULL
 * cdef void* __nvmlDeviceGetJpgUtilization = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetOfaUtilization = NULL
 * cdef void* __nvmlDeviceGetFBCStats = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetJpgUtilization = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":184
 * cdef void* __nvmlDeviceGetDecoderUtilization = NULL
 * cdef void* __nvmlDeviceGetJpgUtilization = NULL
 * cdef void* __nvmlDeviceGetOfaUtilization = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetFBCStats = NULL
 * cdef void* __nvmlDeviceGetFBCSessions = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetOfaUtilization = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":185
 * cdef void* __nvmlDeviceGetJpgUtilization = NULL
 * cdef void* __nvmlDeviceGetOfaUtilization = NULL
 * cdef void* __nvmlDeviceGetFBCStats = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetFBCSessions = NULL
 * cdef void* __nvmlDeviceGetDriverModel_v2 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFBCStats = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":186
 * cdef void* __nvmlDeviceGetOfaUtilization = NULL
 * cdef void* __nvmlDeviceGetFBCStats = NULL
 * cdef void* __nvmlDeviceGetFBCSessions = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetDriverModel_v2 = NULL
 * cdef void* __nvmlDeviceGetVbiosVersion = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFBCSessions = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":187
 * cdef void* __nvmlDeviceGetFBCStats = NULL
 * cdef void* __nvmlDeviceGetFBCSessions = NULL
 * cdef void* __nvmlDeviceGetDriverModel_v2 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetVbiosVersion = NULL
 * cdef void* __nvmlDeviceGetBridgeChipInfo = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDriverModel_v2 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":188
 * cdef void* __nvmlDeviceGetFBCSessions = NULL
 * cdef void* __nvmlDeviceGetDriverModel_v2 = NULL
 * cdef void* __nvmlDeviceGetVbiosVersion = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetBridgeChipInfo = NULL
 * cdef void* __nvmlDeviceGetComputeRunningProcesses_v3 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVbiosVersion = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":189
 * cdef void* __nvmlDeviceGetDriverModel_v2 = NULL
 * cdef void* __nvmlDeviceGetVbiosVersion = NULL
 * cdef void* __nvmlDeviceGetBridgeChipInfo = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetComputeRunningProcesses_v3 = NULL
 * cdef void* __nvmlDeviceGetMPSComputeRunningProcesses_v3 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBridgeChipInfo = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":190
 * cdef void* __nvmlDeviceGetVbiosVersion = NULL
 * cdef void* __nvmlDeviceGetBridgeChipInfo = NULL
 * cdef void* __nvmlDeviceGetComputeRunningProcesses_v3 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetMPSComputeRunningProcesses_v3 = NULL
 * cdef void* __nvmlDeviceGetRunningProcessDetailList = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetComputeRunningProcesses_v3 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":191
 * cdef void* __nvmlDeviceGetBridgeChipInfo = NULL
 * cdef void* __nvmlDeviceGetComputeRunningProcesses_v3 = NULL
 * cdef void* __nvmlDeviceGetMPSComputeRunningProcesses_v3 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetRunningProcessDetailList = NULL
 * cdef void* __nvmlDeviceOnSameBoard = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMPSComputeRunningProcesses_v3 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":192
 * cdef void* __nvmlDeviceGetComputeRunningProcesses_v3 = NULL
 * cdef void* __nvmlDeviceGetMPSComputeRunningProcesses_v3 = NULL
 * cdef void* __nvmlDeviceGetRunningProcessDetailList = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceOnSameBoard = NULL
 * cdef void* __nvmlDeviceGetAPIRestriction = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRunningProcessDetailList = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":193
 * cdef void* __nvmlDeviceGetMPSComputeRunningProcesses_v3 = NULL
 * cdef void* __nvmlDeviceGetRunningProcessDetailList = NULL
 * cdef void* __nvmlDeviceOnSameBoard = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetAPIRestriction = NULL
 * cdef void* __nvmlDeviceGetSamples = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceOnSameBoard = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":194
 * cdef void* __nvmlDeviceGetRunningProcessDetailList = NULL
 * cdef void* __nvmlDeviceOnSameBoard = NULL
 * cdef void* __nvmlDeviceGetAPIRestriction = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetSamples = NULL
 * cdef void* __nvmlDeviceGetBAR1MemoryInfo = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAPIRestriction = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":195
 * cdef void* __nvmlDeviceOnSameBoard = NULL
 * cdef void* __nvmlDeviceGetAPIRestriction = NULL
 * cdef void* __nvmlDeviceGetSamples = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetBAR1MemoryInfo = NULL
 * cdef void* __nvmlDeviceGetIrqNum = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSamples = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":196
 * cdef void* __nvmlDeviceGetAPIRestriction = NULL
 * cdef void* __nvmlDeviceGetSamples = NULL
 * cdef void* __nvmlDeviceGetBAR1MemoryInfo = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetIrqNum = NULL
 * cdef void* __nvmlDeviceGetNumGpuCores = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBAR1MemoryInfo = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":197
 * cdef void* __nvmlDeviceGetSamples = NULL
 * cdef void* __nvmlDeviceGetBAR1MemoryInfo = NULL
 * cdef void* __nvmlDeviceGetIrqNum = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetNumGpuCores = NULL
 * cdef void* __nvmlDeviceGetPowerSource = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetIrqNum = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":198
 * cdef void* __nvmlDeviceGetBAR1MemoryInfo = NULL
 * cdef void* __nvmlDeviceGetIrqNum = NULL
 * cdef void* __nvmlDeviceGetNumGpuCores = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetPowerSource = NULL
 * cdef void* __nvmlDeviceGetMemoryBusWidth = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNumGpuCores = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":199
 * cdef void* __nvmlDeviceGetIrqNum = NULL
 * cdef void* __nvmlDeviceGetNumGpuCores = NULL
 * cdef void* __nvmlDeviceGetPowerSource = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetMemoryBusWidth = NULL
 * cdef void* __nvmlDeviceGetPcieLinkMaxSpeed = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerSource = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":200
 * cdef void* __nvmlDeviceGetNumGpuCores = NULL
 * cdef void* __nvmlDeviceGetPowerSource = NULL
 * cdef void* __nvmlDeviceGetMemoryBusWidth = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetPcieLinkMaxSpeed = NULL
 * cdef void* __nvmlDeviceGetPcieSpeed = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMemoryBusWidth = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":201
 * cdef void* __nvmlDeviceGetPowerSource = NULL
 * cdef void* __nvmlDeviceGetMemoryBusWidth = NULL
 * cdef void* __nvmlDeviceGetPcieLinkMaxSpeed = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetPcieSpeed = NULL
 * cdef void* __nvmlDeviceGetAdaptiveClockInfoStatus = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieLinkMaxSpeed = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":202
 * cdef void* __nvmlDeviceGetMemoryBusWidth = NULL
 * cdef void* __nvmlDeviceGetPcieLinkMaxSpeed = NULL
 * cdef void* __nvmlDeviceGetPcieSpeed = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetAdaptiveClockInfoStatus = NULL
 * cdef void* __nvmlDeviceGetBusType = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPcieSpeed = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":203
 * cdef void* __nvmlDeviceGetPcieLinkMaxSpeed = NULL
 * cdef void* __nvmlDeviceGetPcieSpeed = NULL
 * cdef void* __nvmlDeviceGetAdaptiveClockInfoStatus = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetBusType = NULL
 * cdef void* __nvmlDeviceGetGpuFabricInfoV = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAdaptiveClockInfoStatus = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":204
 * cdef void* __nvmlDeviceGetPcieSpeed = NULL
 * cdef void* __nvmlDeviceGetAdaptiveClockInfoStatus = NULL
 * cdef void* __nvmlDeviceGetBusType = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetGpuFabricInfoV = NULL
 * cdef void* __nvmlSystemGetConfComputeCapabilities = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetBusType = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":205
 * cdef void* __nvmlDeviceGetAdaptiveClockInfoStatus = NULL
 * cdef void* __nvmlDeviceGetBusType = NULL
 * cdef void* __nvmlDeviceGetGpuFabricInfoV = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlSystemGetConfComputeCapabilities = NULL
 * cdef void* __nvmlSystemGetConfComputeState = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuFabricInfoV = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":206
 * cdef void* __nvmlDeviceGetBusType = NULL
 * cdef void* __nvmlDeviceGetGpuFabricInfoV = NULL
 * cdef void* __nvmlSystemGetConfComputeCapabilities = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlSystemGetConfComputeState = NULL
 * cdef void* __nvmlDeviceGetConfComputeMemSizeInfo = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeCapabilities = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":207
 * cdef void* __nvmlDeviceGetGpuFabricInfoV = NULL
 * cdef void* __nvmlSystemGetConfComputeCapabilities = NULL
 * cdef void* __nvmlSystemGetConfComputeState = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetConfComputeMemSizeInfo = NULL
 * cdef void* __nvmlSystemGetConfComputeGpusReadyState = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeState = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":208
 * cdef void* __nvmlSystemGetConfComputeCapabilities = NULL
 * cdef void* __nvmlSystemGetConfComputeState = NULL
 * cdef void* __nvmlDeviceGetConfComputeMemSizeInfo = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlSystemGetConfComputeGpusReadyState = NULL
 * cdef void* __nvmlDeviceGetConfComputeProtectedMemoryUsage = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeMemSizeInfo = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":209
 * cdef void* __nvmlSystemGetConfComputeState = NULL
 * cdef void* __nvmlDeviceGetConfComputeMemSizeInfo = NULL
 * cdef void* __nvmlSystemGetConfComputeGpusReadyState = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetConfComputeProtectedMemoryUsage = NULL
 * cdef void* __nvmlDeviceGetConfComputeGpuCertificate = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeGpusReadyState = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":210
 * cdef void* __nvmlDeviceGetConfComputeMemSizeInfo = NULL
 * cdef void* __nvmlSystemGetConfComputeGpusReadyState = NULL
 * cdef void* __nvmlDeviceGetConfComputeProtectedMemoryUsage = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetConfComputeGpuCertificate = NULL
 * cdef void* __nvmlDeviceGetConfComputeGpuAttestationReport = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeProtectedMemoryUsage = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":211
 * cdef void* __nvmlSystemGetConfComputeGpusReadyState = NULL
 * cdef void* __nvmlDeviceGetConfComputeProtectedMemoryUsage = NULL
 * cdef void* __nvmlDeviceGetConfComputeGpuCertificate = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetConfComputeGpuAttestationReport = NULL
 * cdef void* __nvmlSystemGetConfComputeKeyRotationThresholdInfo = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeGpuCertificate = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":212
 * cdef void* __nvmlDeviceGetConfComputeProtectedMemoryUsage = NULL
 * cdef void* __nvmlDeviceGetConfComputeGpuCertificate = NULL
 * cdef void* __nvmlDeviceGetConfComputeGpuAttestationReport = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlSystemGetConfComputeKeyRotationThresholdInfo = NULL
 * cdef void* __nvmlDeviceSetConfComputeUnprotectedMemSize = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetConfComputeGpuAttestationReport = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":213
 * cdef void* __nvmlDeviceGetConfComputeGpuCertificate = NULL
 * cdef void* __nvmlDeviceGetConfComputeGpuAttestationReport = NULL
 * cdef void* __nvmlSystemGetConfComputeKeyRotationThresholdInfo = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetConfComputeUnprotectedMemSize = NULL
 * cdef void* __nvmlSystemSetConfComputeGpusReadyState = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeKeyRotationThresholdInfo = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":214
 * cdef void* __nvmlDeviceGetConfComputeGpuAttestationReport = NULL
 * cdef void* __nvmlSystemGetConfComputeKeyRotationThresholdInfo = NULL
 * cdef void* __nvmlDeviceSetConfComputeUnprotectedMemSize = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlSystemSetConfComputeGpusReadyState = NULL
 * cdef void* __nvmlSystemSetConfComputeKeyRotationThresholdInfo = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetConfComputeUnprotectedMemSize = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":215
 * cdef void* __nvmlSystemGetConfComputeKeyRotationThresholdInfo = NULL
 * cdef void* __nvmlDeviceSetConfComputeUnprotectedMemSize = NULL
 * cdef void* __nvmlSystemSetConfComputeGpusReadyState = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlSystemSetConfComputeKeyRotationThresholdInfo = NULL
 * cdef void* __nvmlSystemGetConfComputeSettings = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemSetConfComputeGpusReadyState = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":216
 * cdef void* __nvmlDeviceSetConfComputeUnprotectedMemSize = NULL
 * cdef void* __nvmlSystemSetConfComputeGpusReadyState = NULL
 * cdef void* __nvmlSystemSetConfComputeKeyRotationThresholdInfo = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlSystemGetConfComputeSettings = NULL
 * cdef void* __nvmlDeviceGetGspFirmwareVersion = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemSetConfComputeKeyRotationThresholdInfo = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":217
 * cdef void* __nvmlSystemSetConfComputeGpusReadyState = NULL
 * cdef void* __nvmlSystemSetConfComputeKeyRotationThresholdInfo = NULL
 * cdef void* __nvmlSystemGetConfComputeSettings = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetGspFirmwareVersion = NULL
 * cdef void* __nvmlDeviceGetGspFirmwareMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetConfComputeSettings = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":218
 * cdef void* __nvmlSystemSetConfComputeKeyRotationThresholdInfo = NULL
 * cdef void* __nvmlSystemGetConfComputeSettings = NULL
 * cdef void* __nvmlDeviceGetGspFirmwareVersion = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetGspFirmwareMode = NULL
 * cdef void* __nvmlDeviceGetSramEccErrorStatus = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGspFirmwareVersion = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":219
 * cdef void* __nvmlSystemGetConfComputeSettings = NULL
 * cdef void* __nvmlDeviceGetGspFirmwareVersion = NULL
 * cdef void* __nvmlDeviceGetGspFirmwareMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetSramEccErrorStatus = NULL
 * cdef void* __nvmlDeviceGetAccountingMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGspFirmwareMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":220
 * cdef void* __nvmlDeviceGetGspFirmwareVersion = NULL
 * cdef void* __nvmlDeviceGetGspFirmwareMode = NULL
 * cdef void* __nvmlDeviceGetSramEccErrorStatus = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetAccountingMode = NULL
 * cdef void* __nvmlDeviceGetAccountingStats = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSramEccErrorStatus = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":221
 * cdef void* __nvmlDeviceGetGspFirmwareMode = NULL
 * cdef void* __nvmlDeviceGetSramEccErrorStatus = NULL
 * cdef void* __nvmlDeviceGetAccountingMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetAccountingStats = NULL
 * cdef void* __nvmlDeviceGetAccountingPids = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":222
 * cdef void* __nvmlDeviceGetSramEccErrorStatus = NULL
 * cdef void* __nvmlDeviceGetAccountingMode = NULL
 * cdef void* __nvmlDeviceGetAccountingStats = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetAccountingPids = NULL
 * cdef void* __nvmlDeviceGetAccountingBufferSize = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingStats = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":223
 * cdef void* __nvmlDeviceGetAccountingMode = NULL
 * cdef void* __nvmlDeviceGetAccountingStats = NULL
 * cdef void* __nvmlDeviceGetAccountingPids = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetAccountingBufferSize = NULL
 * cdef void* __nvmlDeviceGetRetiredPages = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingPids = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":224
 * cdef void* __nvmlDeviceGetAccountingStats = NULL
 * cdef void* __nvmlDeviceGetAccountingPids = NULL
 * cdef void* __nvmlDeviceGetAccountingBufferSize = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetRetiredPages = NULL
 * cdef void* __nvmlDeviceGetRetiredPages_v2 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAccountingBufferSize = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":225
 * cdef void* __nvmlDeviceGetAccountingPids = NULL
 * cdef void* __nvmlDeviceGetAccountingBufferSize = NULL
 * cdef void* __nvmlDeviceGetRetiredPages = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetRetiredPages_v2 = NULL
 * cdef void* __nvmlDeviceGetRetiredPagesPendingStatus = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRetiredPages = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":226
 * cdef void* __nvmlDeviceGetAccountingBufferSize = NULL
 * cdef void* __nvmlDeviceGetRetiredPages = NULL
 * cdef void* __nvmlDeviceGetRetiredPages_v2 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetRetiredPagesPendingStatus = NULL
 * cdef void* __nvmlDeviceGetRemappedRows = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRetiredPages_v2 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":227
 * cdef void* __nvmlDeviceGetRetiredPages = NULL
 * cdef void* __nvmlDeviceGetRetiredPages_v2 = NULL
 * cdef void* __nvmlDeviceGetRetiredPagesPendingStatus = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetRemappedRows = NULL
 * cdef void* __nvmlDeviceGetRowRemapperHistogram = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRetiredPagesPendingStatus = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":228
 * cdef void* __nvmlDeviceGetRetiredPages_v2 = NULL
 * cdef void* __nvmlDeviceGetRetiredPagesPendingStatus = NULL
 * cdef void* __nvmlDeviceGetRemappedRows = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetRowRemapperHistogram = NULL
 * cdef void* __nvmlDeviceGetArchitecture = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRemappedRows = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":229
 * cdef void* __nvmlDeviceGetRetiredPagesPendingStatus = NULL
 * cdef void* __nvmlDeviceGetRemappedRows = NULL
 * cdef void* __nvmlDeviceGetRowRemapperHistogram = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetArchitecture = NULL
 * cdef void* __nvmlDeviceGetClkMonStatus = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRowRemapperHistogram = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":230
 * cdef void* __nvmlDeviceGetRemappedRows = NULL
 * cdef void* __nvmlDeviceGetRowRemapperHistogram = NULL
 * cdef void* __nvmlDeviceGetArchitecture = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetClkMonStatus = NULL
 * cdef void* __nvmlDeviceGetProcessUtilization = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetArchitecture = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":231
 * cdef void* __nvmlDeviceGetRowRemapperHistogram = NULL
 * cdef void* __nvmlDeviceGetArchitecture = NULL
 * cdef void* __nvmlDeviceGetClkMonStatus = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetProcessUtilization = NULL
 * cdef void* __nvmlDeviceGetProcessesUtilizationInfo = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetClkMonStatus = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":232
 * cdef void* __nvmlDeviceGetArchitecture = NULL
 * cdef void* __nvmlDeviceGetClkMonStatus = NULL
 * cdef void* __nvmlDeviceGetProcessUtilization = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetProcessesUtilizationInfo = NULL
 * cdef void* __nvmlDeviceGetPlatformInfo = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetProcessUtilization = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":233
 * cdef void* __nvmlDeviceGetClkMonStatus = NULL
 * cdef void* __nvmlDeviceGetProcessUtilization = NULL
 * cdef void* __nvmlDeviceGetProcessesUtilizationInfo = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetPlatformInfo = NULL
 * cdef void* __nvmlUnitSetLedState = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetProcessesUtilizationInfo = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":234
 * cdef void* __nvmlDeviceGetProcessUtilization = NULL
 * cdef void* __nvmlDeviceGetProcessesUtilizationInfo = NULL
 * cdef void* __nvmlDeviceGetPlatformInfo = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlUnitSetLedState = NULL
 * cdef void* __nvmlDeviceSetPersistenceMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPlatformInfo = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":235
 * cdef void* __nvmlDeviceGetProcessesUtilizationInfo = NULL
 * cdef void* __nvmlDeviceGetPlatformInfo = NULL
 * cdef void* __nvmlUnitSetLedState = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetPersistenceMode = NULL
 * cdef void* __nvmlDeviceSetComputeMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlUnitSetLedState = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":236
 * cdef void* __nvmlDeviceGetPlatformInfo = NULL
 * cdef void* __nvmlUnitSetLedState = NULL
 * cdef void* __nvmlDeviceSetPersistenceMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetComputeMode = NULL
 * cdef void* __nvmlDeviceSetEccMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPersistenceMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":237
 * cdef void* __nvmlUnitSetLedState = NULL
 * cdef void* __nvmlDeviceSetPersistenceMode = NULL
 * cdef void* __nvmlDeviceSetComputeMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetEccMode = NULL
 * cdef void* __nvmlDeviceClearEccErrorCounts = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetComputeMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":238
 * cdef void* __nvmlDeviceSetPersistenceMode = NULL
 * cdef void* __nvmlDeviceSetComputeMode = NULL
 * cdef void* __nvmlDeviceSetEccMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceClearEccErrorCounts = NULL
 * cdef void* __nvmlDeviceSetDriverModel = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetEccMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":239
 * cdef void* __nvmlDeviceSetComputeMode = NULL
 * cdef void* __nvmlDeviceSetEccMode = NULL
 * cdef void* __nvmlDeviceClearEccErrorCounts = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetDriverModel = NULL
 * cdef void* __nvmlDeviceSetGpuLockedClocks = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearEccErrorCounts = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":240
 * cdef void* __nvmlDeviceSetEccMode = NULL
 * cdef void* __nvmlDeviceClearEccErrorCounts = NULL
 * cdef void* __nvmlDeviceSetDriverModel = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetGpuLockedClocks = NULL
 * cdef void* __nvmlDeviceResetGpuLockedClocks = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDriverModel = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":241
 * cdef void* __nvmlDeviceClearEccErrorCounts = NULL
 * cdef void* __nvmlDeviceSetDriverModel = NULL
 * cdef void* __nvmlDeviceSetGpuLockedClocks = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceResetGpuLockedClocks = NULL
 * cdef void* __nvmlDeviceSetMemoryLockedClocks = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetGpuLockedClocks = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":242
 * cdef void* __nvmlDeviceSetDriverModel = NULL
 * cdef void* __nvmlDeviceSetGpuLockedClocks = NULL
 * cdef void* __nvmlDeviceResetGpuLockedClocks = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetMemoryLockedClocks = NULL
 * cdef void* __nvmlDeviceResetMemoryLockedClocks = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceResetGpuLockedClocks = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":243
 * cdef void* __nvmlDeviceSetGpuLockedClocks = NULL
 * cdef void* __nvmlDeviceResetGpuLockedClocks = NULL
 * cdef void* __nvmlDeviceSetMemoryLockedClocks = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceResetMemoryLockedClocks = NULL
 * cdef void* __nvmlDeviceSetAutoBoostedClocksEnabled = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetMemoryLockedClocks = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":244
 * cdef void* __nvmlDeviceResetGpuLockedClocks = NULL
 * cdef void* __nvmlDeviceSetMemoryLockedClocks = NULL
 * cdef void* __nvmlDeviceResetMemoryLockedClocks = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetAutoBoostedClocksEnabled = NULL
 * cdef void* __nvmlDeviceSetDefaultAutoBoostedClocksEnabled = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceResetMemoryLockedClocks = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":245
 * cdef void* __nvmlDeviceSetMemoryLockedClocks = NULL
 * cdef void* __nvmlDeviceResetMemoryLockedClocks = NULL
 * cdef void* __nvmlDeviceSetAutoBoostedClocksEnabled = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetDefaultAutoBoostedClocksEnabled = NULL
 * cdef void* __nvmlDeviceSetDefaultFanSpeed_v2 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetAutoBoostedClocksEnabled = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":246
 * cdef void* __nvmlDeviceResetMemoryLockedClocks = NULL
 * cdef void* __nvmlDeviceSetAutoBoostedClocksEnabled = NULL
 * cdef void* __nvmlDeviceSetDefaultAutoBoostedClocksEnabled = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetDefaultFanSpeed_v2 = NULL
 * cdef void* __nvmlDeviceSetFanControlPolicy = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDefaultAutoBoostedClocksEnabled = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":247
 * cdef void* __nvmlDeviceSetAutoBoostedClocksEnabled = NULL
 * cdef void* __nvmlDeviceSetDefaultAutoBoostedClocksEnabled = NULL
 * cdef void* __nvmlDeviceSetDefaultFanSpeed_v2 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetFanControlPolicy = NULL
 * cdef void* __nvmlDeviceSetTemperatureThreshold = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetDefaultFanSpeed_v2 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":248
 * cdef void* __nvmlDeviceSetDefaultAutoBoostedClocksEnabled = NULL
 * cdef void* __nvmlDeviceSetDefaultFanSpeed_v2 = NULL
 * cdef void* __nvmlDeviceSetFanControlPolicy = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetTemperatureThreshold = NULL
 * cdef void* __nvmlDeviceSetPowerManagementLimit = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetFanControlPolicy = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":249
 * cdef void* __nvmlDeviceSetDefaultFanSpeed_v2 = NULL
 * cdef void* __nvmlDeviceSetFanControlPolicy = NULL
 * cdef void* __nvmlDeviceSetTemperatureThreshold = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetPowerManagementLimit = NULL
 * cdef void* __nvmlDeviceSetGpuOperationMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetTemperatureThreshold = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":250
 * cdef void* __nvmlDeviceSetFanControlPolicy = NULL
 * cdef void* __nvmlDeviceSetTemperatureThreshold = NULL
 * cdef void* __nvmlDeviceSetPowerManagementLimit = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetGpuOperationMode = NULL
 * cdef void* __nvmlDeviceSetAPIRestriction = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPowerManagementLimit = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":251
 * cdef void* __nvmlDeviceSetTemperatureThreshold = NULL
 * cdef void* __nvmlDeviceSetPowerManagementLimit = NULL
 * cdef void* __nvmlDeviceSetGpuOperationMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetAPIRestriction = NULL
 * cdef void* __nvmlDeviceSetFanSpeed_v2 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetGpuOperationMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":252
 * cdef void* __nvmlDeviceSetPowerManagementLimit = NULL
 * cdef void* __nvmlDeviceSetGpuOperationMode = NULL
 * cdef void* __nvmlDeviceSetAPIRestriction = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetFanSpeed_v2 = NULL
 * cdef void* __nvmlDeviceSetAccountingMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetAPIRestriction = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":253
 * cdef void* __nvmlDeviceSetGpuOperationMode = NULL
 * cdef void* __nvmlDeviceSetAPIRestriction = NULL
 * cdef void* __nvmlDeviceSetFanSpeed_v2 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetAccountingMode = NULL
 * cdef void* __nvmlDeviceClearAccountingPids = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetFanSpeed_v2 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":254
 * cdef void* __nvmlDeviceSetAPIRestriction = NULL
 * cdef void* __nvmlDeviceSetFanSpeed_v2 = NULL
 * cdef void* __nvmlDeviceSetAccountingMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceClearAccountingPids = NULL
 * cdef void* __nvmlDeviceSetPowerManagementLimit_v2 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetAccountingMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":255
 * cdef void* __nvmlDeviceSetFanSpeed_v2 = NULL
 * cdef void* __nvmlDeviceSetAccountingMode = NULL
 * cdef void* __nvmlDeviceClearAccountingPids = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetPowerManagementLimit_v2 = NULL
 * cdef void* __nvmlDeviceGetNvLinkState = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearAccountingPids = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":256
 * cdef void* __nvmlDeviceSetAccountingMode = NULL
 * cdef void* __nvmlDeviceClearAccountingPids = NULL
 * cdef void* __nvmlDeviceSetPowerManagementLimit_v2 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetNvLinkState = NULL
 * cdef void* __nvmlDeviceGetNvLinkVersion = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPowerManagementLimit_v2 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":257
 * cdef void* __nvmlDeviceClearAccountingPids = NULL
 * cdef void* __nvmlDeviceSetPowerManagementLimit_v2 = NULL
 * cdef void* __nvmlDeviceGetNvLinkState = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetNvLinkVersion = NULL
 * cdef void* __nvmlDeviceGetNvLinkCapability = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkState = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":258
 * cdef void* __nvmlDeviceSetPowerManagementLimit_v2 = NULL
 * cdef void* __nvmlDeviceGetNvLinkState = NULL
 * cdef void* __nvmlDeviceGetNvLinkVersion = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetNvLinkCapability = NULL
 * cdef void* __nvmlDeviceGetNvLinkRemotePciInfo_v2 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkVersion = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":259
 * cdef void* __nvmlDeviceGetNvLinkState = NULL
 * cdef void* __nvmlDeviceGetNvLinkVersion = NULL
 * cdef void* __nvmlDeviceGetNvLinkCapability = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetNvLinkRemotePciInfo_v2 = NULL
 * cdef void* __nvmlDeviceGetNvLinkErrorCounter = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkCapability = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":260
 * cdef void* __nvmlDeviceGetNvLinkVersion = NULL
 * cdef void* __nvmlDeviceGetNvLinkCapability = NULL
 * cdef void* __nvmlDeviceGetNvLinkRemotePciInfo_v2 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetNvLinkErrorCounter = NULL
 * cdef void* __nvmlDeviceResetNvLinkErrorCounters = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkRemotePciInfo_v2 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":261
 * cdef void* __nvmlDeviceGetNvLinkCapability = NULL
 * cdef void* __nvmlDeviceGetNvLinkRemotePciInfo_v2 = NULL
 * cdef void* __nvmlDeviceGetNvLinkErrorCounter = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceResetNvLinkErrorCounters = NULL
 * cdef void* __nvmlDeviceGetNvLinkRemoteDeviceType = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkErrorCounter = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":262
 * cdef void* __nvmlDeviceGetNvLinkRemotePciInfo_v2 = NULL
 * cdef void* __nvmlDeviceGetNvLinkErrorCounter = NULL
 * cdef void* __nvmlDeviceResetNvLinkErrorCounters = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetNvLinkRemoteDeviceType = NULL
 * cdef void* __nvmlDeviceSetNvLinkDeviceLowPowerThreshold = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceResetNvLinkErrorCounters = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":263
 * cdef void* __nvmlDeviceGetNvLinkErrorCounter = NULL
 * cdef void* __nvmlDeviceResetNvLinkErrorCounters = NULL
 * cdef void* __nvmlDeviceGetNvLinkRemoteDeviceType = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetNvLinkDeviceLowPowerThreshold = NULL
 * cdef void* __nvmlSystemSetNvlinkBwMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkRemoteDeviceType = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":264
 * cdef void* __nvmlDeviceResetNvLinkErrorCounters = NULL
 * cdef void* __nvmlDeviceGetNvLinkRemoteDeviceType = NULL
 * cdef void* __nvmlDeviceSetNvLinkDeviceLowPowerThreshold = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlSystemSetNvlinkBwMode = NULL
 * cdef void* __nvmlSystemGetNvlinkBwMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetNvLinkDeviceLowPowerThreshold = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":265
 * cdef void* __nvmlDeviceGetNvLinkRemoteDeviceType = NULL
 * cdef void* __nvmlDeviceSetNvLinkDeviceLowPowerThreshold = NULL
 * cdef void* __nvmlSystemSetNvlinkBwMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlSystemGetNvlinkBwMode = NULL
 * cdef void* __nvmlDeviceGetNvlinkSupportedBwModes = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemSetNvlinkBwMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":266
 * cdef void* __nvmlDeviceSetNvLinkDeviceLowPowerThreshold = NULL
 * cdef void* __nvmlSystemSetNvlinkBwMode = NULL
 * cdef void* __nvmlSystemGetNvlinkBwMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetNvlinkSupportedBwModes = NULL
 * cdef void* __nvmlDeviceGetNvlinkBwMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemGetNvlinkBwMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":267
 * cdef void* __nvmlSystemSetNvlinkBwMode = NULL
 * cdef void* __nvmlSystemGetNvlinkBwMode = NULL
 * cdef void* __nvmlDeviceGetNvlinkSupportedBwModes = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetNvlinkBwMode = NULL
 * cdef void* __nvmlDeviceSetNvlinkBwMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvlinkSupportedBwModes = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":268
 * cdef void* __nvmlSystemGetNvlinkBwMode = NULL
 * cdef void* __nvmlDeviceGetNvlinkSupportedBwModes = NULL
 * cdef void* __nvmlDeviceGetNvlinkBwMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetNvlinkBwMode = NULL
 * cdef void* __nvmlEventSetCreate = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvlinkBwMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":269
 * cdef void* __nvmlDeviceGetNvlinkSupportedBwModes = NULL
 * cdef void* __nvmlDeviceGetNvlinkBwMode = NULL
 * cdef void* __nvmlDeviceSetNvlinkBwMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlEventSetCreate = NULL
 * cdef void* __nvmlDeviceRegisterEvents = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetNvlinkBwMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":270
 * cdef void* __nvmlDeviceGetNvlinkBwMode = NULL
 * cdef void* __nvmlDeviceSetNvlinkBwMode = NULL
 * cdef void* __nvmlEventSetCreate = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceRegisterEvents = NULL
 * cdef void* __nvmlDeviceGetSupportedEventTypes = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlEventSetCreate = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":271
 * cdef void* __nvmlDeviceSetNvlinkBwMode = NULL
 * cdef void* __nvmlEventSetCreate = NULL
 * cdef void* __nvmlDeviceRegisterEvents = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetSupportedEventTypes = NULL
 * cdef void* __nvmlEventSetWait_v2 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceRegisterEvents = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":272
 * cdef void* __nvmlEventSetCreate = NULL
 * cdef void* __nvmlDeviceRegisterEvents = NULL
 * cdef void* __nvmlDeviceGetSupportedEventTypes = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlEventSetWait_v2 = NULL
 * cdef void* __nvmlEventSetFree = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedEventTypes = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":273
 * cdef void* __nvmlDeviceRegisterEvents = NULL
 * cdef void* __nvmlDeviceGetSupportedEventTypes = NULL
 * cdef void* __nvmlEventSetWait_v2 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlEventSetFree = NULL
 * cdef void* __nvmlSystemEventSetCreate = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlEventSetWait_v2 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":274
 * cdef void* __nvmlDeviceGetSupportedEventTypes = NULL
 * cdef void* __nvmlEventSetWait_v2 = NULL
 * cdef void* __nvmlEventSetFree = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlSystemEventSetCreate = NULL
 * cdef void* __nvmlSystemEventSetFree = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlEventSetFree = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":275
 * cdef void* __nvmlEventSetWait_v2 = NULL
 * cdef void* __nvmlEventSetFree = NULL
 * cdef void* __nvmlSystemEventSetCreate = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlSystemEventSetFree = NULL
 * cdef void* __nvmlSystemRegisterEvents = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemEventSetCreate = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":276
 * cdef void* __nvmlEventSetFree = NULL
 * cdef void* __nvmlSystemEventSetCreate = NULL
 * cdef void* __nvmlSystemEventSetFree = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlSystemRegisterEvents = NULL
 * cdef void* __nvmlSystemEventSetWait = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemEventSetFree = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":277
 * cdef void* __nvmlSystemEventSetCreate = NULL
 * cdef void* __nvmlSystemEventSetFree = NULL
 * cdef void* __nvmlSystemRegisterEvents = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlSystemEventSetWait = NULL
 * cdef void* __nvmlDeviceModifyDrainState = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemRegisterEvents = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":278
 * cdef void* __nvmlSystemEventSetFree = NULL
 * cdef void* __nvmlSystemRegisterEvents = NULL
 * cdef void* __nvmlSystemEventSetWait = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceModifyDrainState = NULL
 * cdef void* __nvmlDeviceQueryDrainState = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSystemEventSetWait = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":279
 * cdef void* __nvmlSystemRegisterEvents = NULL
 * cdef void* __nvmlSystemEventSetWait = NULL
 * cdef void* __nvmlDeviceModifyDrainState = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceQueryDrainState = NULL
 * cdef void* __nvmlDeviceRemoveGpu_v2 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceModifyDrainState = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":280
 * cdef void* __nvmlSystemEventSetWait = NULL
 * cdef void* __nvmlDeviceModifyDrainState = NULL
 * cdef void* __nvmlDeviceQueryDrainState = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceRemoveGpu_v2 = NULL
 * cdef void* __nvmlDeviceDiscoverGpus = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceQueryDrainState = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":281
 * cdef void* __nvmlDeviceModifyDrainState = NULL
 * cdef void* __nvmlDeviceQueryDrainState = NULL
 * cdef void* __nvmlDeviceRemoveGpu_v2 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceDiscoverGpus = NULL
 * cdef void* __nvmlDeviceGetFieldValues = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceRemoveGpu_v2 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":282
 * cdef void* __nvmlDeviceQueryDrainState = NULL
 * cdef void* __nvmlDeviceRemoveGpu_v2 = NULL
 * cdef void* __nvmlDeviceDiscoverGpus = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetFieldValues = NULL
 * cdef void* __nvmlDeviceClearFieldValues = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceDiscoverGpus = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":283
 * cdef void* __nvmlDeviceRemoveGpu_v2 = NULL
 * cdef void* __nvmlDeviceDiscoverGpus = NULL
 * cdef void* __nvmlDeviceGetFieldValues = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceClearFieldValues = NULL
 * cdef void* __nvmlDeviceGetVirtualizationMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetFieldValues = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":284
 * cdef void* __nvmlDeviceDiscoverGpus = NULL
 * cdef void* __nvmlDeviceGetFieldValues = NULL
 * cdef void* __nvmlDeviceClearFieldValues = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetVirtualizationMode = NULL
 * cdef void* __nvmlDeviceGetHostVgpuMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceClearFieldValues = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":285
 * cdef void* __nvmlDeviceGetFieldValues = NULL
 * cdef void* __nvmlDeviceClearFieldValues = NULL
 * cdef void* __nvmlDeviceGetVirtualizationMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetHostVgpuMode = NULL
 * cdef void* __nvmlDeviceSetVirtualizationMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVirtualizationMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":286
 * cdef void* __nvmlDeviceClearFieldValues = NULL
 * cdef void* __nvmlDeviceGetVirtualizationMode = NULL
 * cdef void* __nvmlDeviceGetHostVgpuMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetVirtualizationMode = NULL
 * cdef void* __nvmlDeviceGetVgpuHeterogeneousMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHostVgpuMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":287
 * cdef void* __nvmlDeviceGetVirtualizationMode = NULL
 * cdef void* __nvmlDeviceGetHostVgpuMode = NULL
 * cdef void* __nvmlDeviceSetVirtualizationMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetVgpuHeterogeneousMode = NULL
 * cdef void* __nvmlDeviceSetVgpuHeterogeneousMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVirtualizationMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":288
 * cdef void* __nvmlDeviceGetHostVgpuMode = NULL
 * cdef void* __nvmlDeviceSetVirtualizationMode = NULL
 * cdef void* __nvmlDeviceGetVgpuHeterogeneousMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetVgpuHeterogeneousMode = NULL
 * cdef void* __nvmlVgpuInstanceGetPlacementId = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuHeterogeneousMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":289
 * cdef void* __nvmlDeviceSetVirtualizationMode = NULL
 * cdef void* __nvmlDeviceGetVgpuHeterogeneousMode = NULL
 * cdef void* __nvmlDeviceSetVgpuHeterogeneousMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceGetPlacementId = NULL
 * cdef void* __nvmlDeviceGetVgpuTypeSupportedPlacements = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVgpuHeterogeneousMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":290
 * cdef void* __nvmlDeviceGetVgpuHeterogeneousMode = NULL
 * cdef void* __nvmlDeviceSetVgpuHeterogeneousMode = NULL
 * cdef void* __nvmlVgpuInstanceGetPlacementId = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetVgpuTypeSupportedPlacements = NULL
 * cdef void* __nvmlDeviceGetVgpuTypeCreatablePlacements = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetPlacementId = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":291
 * cdef void* __nvmlDeviceSetVgpuHeterogeneousMode = NULL
 * cdef void* __nvmlVgpuInstanceGetPlacementId = NULL
 * cdef void* __nvmlDeviceGetVgpuTypeSupportedPlacements = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetVgpuTypeCreatablePlacements = NULL
 * cdef void* __nvmlVgpuTypeGetGspHeapSize = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuTypeSupportedPlacements = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":292
 * cdef void* __nvmlVgpuInstanceGetPlacementId = NULL
 * cdef void* __nvmlDeviceGetVgpuTypeSupportedPlacements = NULL
 * cdef void* __nvmlDeviceGetVgpuTypeCreatablePlacements = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuTypeGetGspHeapSize = NULL
 * cdef void* __nvmlVgpuTypeGetFbReservation = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuTypeCreatablePlacements = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":293
 * cdef void* __nvmlDeviceGetVgpuTypeSupportedPlacements = NULL
 * cdef void* __nvmlDeviceGetVgpuTypeCreatablePlacements = NULL
 * cdef void* __nvmlVgpuTypeGetGspHeapSize = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuTypeGetFbReservation = NULL
 * cdef void* __nvmlVgpuInstanceGetRuntimeStateSize = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetGspHeapSize = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":294
 * cdef void* __nvmlDeviceGetVgpuTypeCreatablePlacements = NULL
 * cdef void* __nvmlVgpuTypeGetGspHeapSize = NULL
 * cdef void* __nvmlVgpuTypeGetFbReservation = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceGetRuntimeStateSize = NULL
 * cdef void* __nvmlDeviceSetVgpuCapabilities = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetFbReservation = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":295
 * cdef void* __nvmlVgpuTypeGetGspHeapSize = NULL
 * cdef void* __nvmlVgpuTypeGetFbReservation = NULL
 * cdef void* __nvmlVgpuInstanceGetRuntimeStateSize = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetVgpuCapabilities = NULL
 * cdef void* __nvmlDeviceGetGridLicensableFeatures_v4 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetRuntimeStateSize = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":296
 * cdef void* __nvmlVgpuTypeGetFbReservation = NULL
 * cdef void* __nvmlVgpuInstanceGetRuntimeStateSize = NULL
 * cdef void* __nvmlDeviceSetVgpuCapabilities = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetGridLicensableFeatures_v4 = NULL
 * cdef void* __nvmlGetVgpuDriverCapabilities = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVgpuCapabilities = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":297
 * cdef void* __nvmlVgpuInstanceGetRuntimeStateSize = NULL
 * cdef void* __nvmlDeviceSetVgpuCapabilities = NULL
 * cdef void* __nvmlDeviceGetGridLicensableFeatures_v4 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGetVgpuDriverCapabilities = NULL
 * cdef void* __nvmlDeviceGetVgpuCapabilities = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGridLicensableFeatures_v4 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":298
 * cdef void* __nvmlDeviceSetVgpuCapabilities = NULL
 * cdef void* __nvmlDeviceGetGridLicensableFeatures_v4 = NULL
 * cdef void* __nvmlGetVgpuDriverCapabilities = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetVgpuCapabilities = NULL
 * cdef void* __nvmlDeviceGetSupportedVgpus = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetVgpuDriverCapabilities = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":299
 * cdef void* __nvmlDeviceGetGridLicensableFeatures_v4 = NULL
 * cdef void* __nvmlGetVgpuDriverCapabilities = NULL
 * cdef void* __nvmlDeviceGetVgpuCapabilities = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetSupportedVgpus = NULL
 * cdef void* __nvmlDeviceGetCreatableVgpus = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuCapabilities = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":300
 * cdef void* __nvmlGetVgpuDriverCapabilities = NULL
 * cdef void* __nvmlDeviceGetVgpuCapabilities = NULL
 * cdef void* __nvmlDeviceGetSupportedVgpus = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetCreatableVgpus = NULL
 * cdef void* __nvmlVgpuTypeGetClass = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSupportedVgpus = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":301
 * cdef void* __nvmlDeviceGetVgpuCapabilities = NULL
 * cdef void* __nvmlDeviceGetSupportedVgpus = NULL
 * cdef void* __nvmlDeviceGetCreatableVgpus = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuTypeGetClass = NULL
 * cdef void* __nvmlVgpuTypeGetName = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCreatableVgpus = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":302
 * cdef void* __nvmlDeviceGetSupportedVgpus = NULL
 * cdef void* __nvmlDeviceGetCreatableVgpus = NULL
 * cdef void* __nvmlVgpuTypeGetClass = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuTypeGetName = NULL
 * cdef void* __nvmlVgpuTypeGetGpuInstanceProfileId = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetClass = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":303
 * cdef void* __nvmlDeviceGetCreatableVgpus = NULL
 * cdef void* __nvmlVgpuTypeGetClass = NULL
 * cdef void* __nvmlVgpuTypeGetName = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuTypeGetGpuInstanceProfileId = NULL
 * cdef void* __nvmlVgpuTypeGetDeviceID = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetName = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":304
 * cdef void* __nvmlVgpuTypeGetClass = NULL
 * cdef void* __nvmlVgpuTypeGetName = NULL
 * cdef void* __nvmlVgpuTypeGetGpuInstanceProfileId = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuTypeGetDeviceID = NULL
 * cdef void* __nvmlVgpuTypeGetFramebufferSize = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetGpuInstanceProfileId = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":305
 * cdef void* __nvmlVgpuTypeGetName = NULL
 * cdef void* __nvmlVgpuTypeGetGpuInstanceProfileId = NULL
 * cdef void* __nvmlVgpuTypeGetDeviceID = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuTypeGetFramebufferSize = NULL
 * cdef void* __nvmlVgpuTypeGetNumDisplayHeads = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetDeviceID = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":306
 * cdef void* __nvmlVgpuTypeGetGpuInstanceProfileId = NULL
 * cdef void* __nvmlVgpuTypeGetDeviceID = NULL
 * cdef void* __nvmlVgpuTypeGetFramebufferSize = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuTypeGetNumDisplayHeads = NULL
 * cdef void* __nvmlVgpuTypeGetResolution = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetFramebufferSize = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":307
 * cdef void* __nvmlVgpuTypeGetDeviceID = NULL
 * cdef void* __nvmlVgpuTypeGetFramebufferSize = NULL
 * cdef void* __nvmlVgpuTypeGetNumDisplayHeads = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuTypeGetResolution = NULL
 * cdef void* __nvmlVgpuTypeGetLicense = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetNumDisplayHeads = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":308
 * cdef void* __nvmlVgpuTypeGetFramebufferSize = NULL
 * cdef void* __nvmlVgpuTypeGetNumDisplayHeads = NULL
 * cdef void* __nvmlVgpuTypeGetResolution = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuTypeGetLicense = NULL
 * cdef void* __nvmlVgpuTypeGetFrameRateLimit = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetResolution = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":309
 * cdef void* __nvmlVgpuTypeGetNumDisplayHeads = NULL
 * cdef void* __nvmlVgpuTypeGetResolution = NULL
 * cdef void* __nvmlVgpuTypeGetLicense = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuTypeGetFrameRateLimit = NULL
 * cdef void* __nvmlVgpuTypeGetMaxInstances = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetLicense = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":310
 * cdef void* __nvmlVgpuTypeGetResolution = NULL
 * cdef void* __nvmlVgpuTypeGetLicense = NULL
 * cdef void* __nvmlVgpuTypeGetFrameRateLimit = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuTypeGetMaxInstances = NULL
 * cdef void* __nvmlVgpuTypeGetMaxInstancesPerVm = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetFrameRateLimit = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":311
 * cdef void* __nvmlVgpuTypeGetLicense = NULL
 * cdef void* __nvmlVgpuTypeGetFrameRateLimit = NULL
 * cdef void* __nvmlVgpuTypeGetMaxInstances = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuTypeGetMaxInstancesPerVm = NULL
 * cdef void* __nvmlVgpuTypeGetBAR1Info = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetMaxInstances = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":312
 * cdef void* __nvmlVgpuTypeGetFrameRateLimit = NULL
 * cdef void* __nvmlVgpuTypeGetMaxInstances = NULL
 * cdef void* __nvmlVgpuTypeGetMaxInstancesPerVm = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuTypeGetBAR1Info = NULL
 * cdef void* __nvmlDeviceGetActiveVgpus = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetMaxInstancesPerVm = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":313
 * cdef void* __nvmlVgpuTypeGetMaxInstances = NULL
 * cdef void* __nvmlVgpuTypeGetMaxInstancesPerVm = NULL
 * cdef void* __nvmlVgpuTypeGetBAR1Info = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetActiveVgpus = NULL
 * cdef void* __nvmlVgpuInstanceGetVmID = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetBAR1Info = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":314
 * cdef void* __nvmlVgpuTypeGetMaxInstancesPerVm = NULL
 * cdef void* __nvmlVgpuTypeGetBAR1Info = NULL
 * cdef void* __nvmlDeviceGetActiveVgpus = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceGetVmID = NULL
 * cdef void* __nvmlVgpuInstanceGetUUID = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetActiveVgpus = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":315
 * cdef void* __nvmlVgpuTypeGetBAR1Info = NULL
 * cdef void* __nvmlDeviceGetActiveVgpus = NULL
 * cdef void* __nvmlVgpuInstanceGetVmID = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceGetUUID = NULL
 * cdef void* __nvmlVgpuInstanceGetVmDriverVersion = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetVmID = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":316
 * cdef void* __nvmlDeviceGetActiveVgpus = NULL
 * cdef void* __nvmlVgpuInstanceGetVmID = NULL
 * cdef void* __nvmlVgpuInstanceGetUUID = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceGetVmDriverVersion = NULL
 * cdef void* __nvmlVgpuInstanceGetFbUsage = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetUUID = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":317
 * cdef void* __nvmlVgpuInstanceGetVmID = NULL
 * cdef void* __nvmlVgpuInstanceGetUUID = NULL
 * cdef void* __nvmlVgpuInstanceGetVmDriverVersion = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceGetFbUsage = NULL
 * cdef void* __nvmlVgpuInstanceGetLicenseStatus = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetVmDriverVersion = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":318
 * cdef void* __nvmlVgpuInstanceGetUUID = NULL
 * cdef void* __nvmlVgpuInstanceGetVmDriverVersion = NULL
 * cdef void* __nvmlVgpuInstanceGetFbUsage = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceGetLicenseStatus = NULL
 * cdef void* __nvmlVgpuInstanceGetType = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFbUsage = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":319
 * cdef void* __nvmlVgpuInstanceGetVmDriverVersion = NULL
 * cdef void* __nvmlVgpuInstanceGetFbUsage = NULL
 * cdef void* __nvmlVgpuInstanceGetLicenseStatus = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceGetType = NULL
 * cdef void* __nvmlVgpuInstanceGetFrameRateLimit = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetLicenseStatus = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":320
 * cdef void* __nvmlVgpuInstanceGetFbUsage = NULL
 * cdef void* __nvmlVgpuInstanceGetLicenseStatus = NULL
 * cdef void* __nvmlVgpuInstanceGetType = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceGetFrameRateLimit = NULL
 * cdef void* __nvmlVgpuInstanceGetEccMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetType = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":321
 * cdef void* __nvmlVgpuInstanceGetLicenseStatus = NULL
 * cdef void* __nvmlVgpuInstanceGetType = NULL
 * cdef void* __nvmlVgpuInstanceGetFrameRateLimit = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceGetEccMode = NULL
 * cdef void* __nvmlVgpuInstanceGetEncoderCapacity = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFrameRateLimit = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":322
 * cdef void* __nvmlVgpuInstanceGetType = NULL
 * cdef void* __nvmlVgpuInstanceGetFrameRateLimit = NULL
 * cdef void* __nvmlVgpuInstanceGetEccMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceGetEncoderCapacity = NULL
 * cdef void* __nvmlVgpuInstanceSetEncoderCapacity = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEccMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":323
 * cdef void* __nvmlVgpuInstanceGetFrameRateLimit = NULL
 * cdef void* __nvmlVgpuInstanceGetEccMode = NULL
 * cdef void* __nvmlVgpuInstanceGetEncoderCapacity = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceSetEncoderCapacity = NULL
 * cdef void* __nvmlVgpuInstanceGetEncoderStats = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEncoderCapacity = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":324
 * cdef void* __nvmlVgpuInstanceGetEccMode = NULL
 * cdef void* __nvmlVgpuInstanceGetEncoderCapacity = NULL
 * cdef void* __nvmlVgpuInstanceSetEncoderCapacity = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceGetEncoderStats = NULL
 * cdef void* __nvmlVgpuInstanceGetEncoderSessions = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceSetEncoderCapacity = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":325
 * cdef void* __nvmlVgpuInstanceGetEncoderCapacity = NULL
 * cdef void* __nvmlVgpuInstanceSetEncoderCapacity = NULL
 * cdef void* __nvmlVgpuInstanceGetEncoderStats = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceGetEncoderSessions = NULL
 * cdef void* __nvmlVgpuInstanceGetFBCStats = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEncoderStats = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":326
 * cdef void* __nvmlVgpuInstanceSetEncoderCapacity = NULL
 * cdef void* __nvmlVgpuInstanceGetEncoderStats = NULL
 * cdef void* __nvmlVgpuInstanceGetEncoderSessions = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceGetFBCStats = NULL
 * cdef void* __nvmlVgpuInstanceGetFBCSessions = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetEncoderSessions = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":327
 * cdef void* __nvmlVgpuInstanceGetEncoderStats = NULL
 * cdef void* __nvmlVgpuInstanceGetEncoderSessions = NULL
 * cdef void* __nvmlVgpuInstanceGetFBCStats = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceGetFBCSessions = NULL
 * cdef void* __nvmlVgpuInstanceGetGpuInstanceId = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFBCStats = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":328
 * cdef void* __nvmlVgpuInstanceGetEncoderSessions = NULL
 * cdef void* __nvmlVgpuInstanceGetFBCStats = NULL
 * cdef void* __nvmlVgpuInstanceGetFBCSessions = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceGetGpuInstanceId = NULL
 * cdef void* __nvmlVgpuInstanceGetGpuPciId = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetFBCSessions = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":329
 * cdef void* __nvmlVgpuInstanceGetFBCStats = NULL
 * cdef void* __nvmlVgpuInstanceGetFBCSessions = NULL
 * cdef void* __nvmlVgpuInstanceGetGpuInstanceId = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceGetGpuPciId = NULL
 * cdef void* __nvmlVgpuTypeGetCapabilities = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetGpuInstanceId = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":330
 * cdef void* __nvmlVgpuInstanceGetFBCSessions = NULL
 * cdef void* __nvmlVgpuInstanceGetGpuInstanceId = NULL
 * cdef void* __nvmlVgpuInstanceGetGpuPciId = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuTypeGetCapabilities = NULL
 * cdef void* __nvmlVgpuInstanceGetMdevUUID = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetGpuPciId = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":331
 * cdef void* __nvmlVgpuInstanceGetGpuInstanceId = NULL
 * cdef void* __nvmlVgpuInstanceGetGpuPciId = NULL
 * cdef void* __nvmlVgpuTypeGetCapabilities = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceGetMdevUUID = NULL
 * cdef void* __nvmlGpuInstanceGetCreatableVgpus = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetCapabilities = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":332
 * cdef void* __nvmlVgpuInstanceGetGpuPciId = NULL
 * cdef void* __nvmlVgpuTypeGetCapabilities = NULL
 * cdef void* __nvmlVgpuInstanceGetMdevUUID = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGpuInstanceGetCreatableVgpus = NULL
 * cdef void* __nvmlVgpuTypeGetMaxInstancesPerGpuInstance = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetMdevUUID = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":333
 * cdef void* __nvmlVgpuTypeGetCapabilities = NULL
 * cdef void* __nvmlVgpuInstanceGetMdevUUID = NULL
 * cdef void* __nvmlGpuInstanceGetCreatableVgpus = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuTypeGetMaxInstancesPerGpuInstance = NULL
 * cdef void* __nvmlGpuInstanceGetActiveVgpus = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetCreatableVgpus = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":334
 * cdef void* __nvmlVgpuInstanceGetMdevUUID = NULL
 * cdef void* __nvmlGpuInstanceGetCreatableVgpus = NULL
 * cdef void* __nvmlVgpuTypeGetMaxInstancesPerGpuInstance = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGpuInstanceGetActiveVgpus = NULL
 * cdef void* __nvmlGpuInstanceSetVgpuSchedulerState = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuTypeGetMaxInstancesPerGpuInstance = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":335
 * cdef void* __nvmlGpuInstanceGetCreatableVgpus = NULL
 * cdef void* __nvmlVgpuTypeGetMaxInstancesPerGpuInstance = NULL
 * cdef void* __nvmlGpuInstanceGetActiveVgpus = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGpuInstanceSetVgpuSchedulerState = NULL
 * cdef void* __nvmlGpuInstanceGetVgpuSchedulerState = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetActiveVgpus = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":336
 * cdef void* __nvmlVgpuTypeGetMaxInstancesPerGpuInstance = NULL
 * cdef void* __nvmlGpuInstanceGetActiveVgpus = NULL
 * cdef void* __nvmlGpuInstanceSetVgpuSchedulerState = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGpuInstanceGetVgpuSchedulerState = NULL
 * cdef void* __nvmlGpuInstanceGetVgpuSchedulerLog = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceSetVgpuSchedulerState = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":337
 * cdef void* __nvmlGpuInstanceGetActiveVgpus = NULL
 * cdef void* __nvmlGpuInstanceSetVgpuSchedulerState = NULL
 * cdef void* __nvmlGpuInstanceGetVgpuSchedulerState = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGpuInstanceGetVgpuSchedulerLog = NULL
 * cdef void* __nvmlGpuInstanceGetVgpuTypeCreatablePlacements = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuSchedulerState = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":338
 * cdef void* __nvmlGpuInstanceSetVgpuSchedulerState = NULL
 * cdef void* __nvmlGpuInstanceGetVgpuSchedulerState = NULL
 * cdef void* __nvmlGpuInstanceGetVgpuSchedulerLog = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGpuInstanceGetVgpuTypeCreatablePlacements = NULL
 * cdef void* __nvmlGpuInstanceGetVgpuHeterogeneousMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuSchedulerLog = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":339
 * cdef void* __nvmlGpuInstanceGetVgpuSchedulerState = NULL
 * cdef void* __nvmlGpuInstanceGetVgpuSchedulerLog = NULL
 * cdef void* __nvmlGpuInstanceGetVgpuTypeCreatablePlacements = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGpuInstanceGetVgpuHeterogeneousMode = NULL
 * cdef void* __nvmlGpuInstanceSetVgpuHeterogeneousMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuTypeCreatablePlacements = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":340
 * cdef void* __nvmlGpuInstanceGetVgpuSchedulerLog = NULL
 * cdef void* __nvmlGpuInstanceGetVgpuTypeCreatablePlacements = NULL
 * cdef void* __nvmlGpuInstanceGetVgpuHeterogeneousMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGpuInstanceSetVgpuHeterogeneousMode = NULL
 * cdef void* __nvmlVgpuInstanceGetMetadata = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetVgpuHeterogeneousMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":341
 * cdef void* __nvmlGpuInstanceGetVgpuTypeCreatablePlacements = NULL
 * cdef void* __nvmlGpuInstanceGetVgpuHeterogeneousMode = NULL
 * cdef void* __nvmlGpuInstanceSetVgpuHeterogeneousMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceGetMetadata = NULL
 * cdef void* __nvmlDeviceGetVgpuMetadata = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceSetVgpuHeterogeneousMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":342
 * cdef void* __nvmlGpuInstanceGetVgpuHeterogeneousMode = NULL
 * cdef void* __nvmlGpuInstanceSetVgpuHeterogeneousMode = NULL
 * cdef void* __nvmlVgpuInstanceGetMetadata = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetVgpuMetadata = NULL
 * cdef void* __nvmlGetVgpuCompatibility = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetMetadata = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":343
 * cdef void* __nvmlGpuInstanceSetVgpuHeterogeneousMode = NULL
 * cdef void* __nvmlVgpuInstanceGetMetadata = NULL
 * cdef void* __nvmlDeviceGetVgpuMetadata = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGetVgpuCompatibility = NULL
 * cdef void* __nvmlDeviceGetPgpuMetadataString = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuMetadata = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":344
 * cdef void* __nvmlVgpuInstanceGetMetadata = NULL
 * cdef void* __nvmlDeviceGetVgpuMetadata = NULL
 * cdef void* __nvmlGetVgpuCompatibility = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetPgpuMetadataString = NULL
 * cdef void* __nvmlDeviceGetVgpuSchedulerLog = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetVgpuCompatibility = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":345
 * cdef void* __nvmlDeviceGetVgpuMetadata = NULL
 * cdef void* __nvmlGetVgpuCompatibility = NULL
 * cdef void* __nvmlDeviceGetPgpuMetadataString = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetVgpuSchedulerLog = NULL
 * cdef void* __nvmlDeviceGetVgpuSchedulerState = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPgpuMetadataString = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":346
 * cdef void* __nvmlGetVgpuCompatibility = NULL
 * cdef void* __nvmlDeviceGetPgpuMetadataString = NULL
 * cdef void* __nvmlDeviceGetVgpuSchedulerLog = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetVgpuSchedulerState = NULL
 * cdef void* __nvmlDeviceGetVgpuSchedulerCapabilities = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuSchedulerLog = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":347
 * cdef void* __nvmlDeviceGetPgpuMetadataString = NULL
 * cdef void* __nvmlDeviceGetVgpuSchedulerLog = NULL
 * cdef void* __nvmlDeviceGetVgpuSchedulerState = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetVgpuSchedulerCapabilities = NULL
 * cdef void* __nvmlDeviceSetVgpuSchedulerState = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuSchedulerState = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":348
 * cdef void* __nvmlDeviceGetVgpuSchedulerLog = NULL
 * cdef void* __nvmlDeviceGetVgpuSchedulerState = NULL
 * cdef void* __nvmlDeviceGetVgpuSchedulerCapabilities = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetVgpuSchedulerState = NULL
 * cdef void* __nvmlGetVgpuVersion = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuSchedulerCapabilities = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":349
 * cdef void* __nvmlDeviceGetVgpuSchedulerState = NULL
 * cdef void* __nvmlDeviceGetVgpuSchedulerCapabilities = NULL
 * cdef void* __nvmlDeviceSetVgpuSchedulerState = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGetVgpuVersion = NULL
 * cdef void* __nvmlSetVgpuVersion = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetVgpuSchedulerState = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":350
 * cdef void* __nvmlDeviceGetVgpuSchedulerCapabilities = NULL
 * cdef void* __nvmlDeviceSetVgpuSchedulerState = NULL
 * cdef void* __nvmlGetVgpuVersion = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlSetVgpuVersion = NULL
 * cdef void* __nvmlDeviceGetVgpuUtilization = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetVgpuVersion = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":351
 * cdef void* __nvmlDeviceSetVgpuSchedulerState = NULL
 * cdef void* __nvmlGetVgpuVersion = NULL
 * cdef void* __nvmlSetVgpuVersion = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetVgpuUtilization = NULL
 * cdef void* __nvmlDeviceGetVgpuInstancesUtilizationInfo = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlSetVgpuVersion = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":352
 * cdef void* __nvmlGetVgpuVersion = NULL
 * cdef void* __nvmlSetVgpuVersion = NULL
 * cdef void* __nvmlDeviceGetVgpuUtilization = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetVgpuInstancesUtilizationInfo = NULL
 * cdef void* __nvmlDeviceGetVgpuProcessUtilization = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuUtilization = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":353
 * cdef void* __nvmlSetVgpuVersion = NULL
 * cdef void* __nvmlDeviceGetVgpuUtilization = NULL
 * cdef void* __nvmlDeviceGetVgpuInstancesUtilizationInfo = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetVgpuProcessUtilization = NULL
 * cdef void* __nvmlDeviceGetVgpuProcessesUtilizationInfo = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuInstancesUtilizationInfo = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":354
 * cdef void* __nvmlDeviceGetVgpuUtilization = NULL
 * cdef void* __nvmlDeviceGetVgpuInstancesUtilizationInfo = NULL
 * cdef void* __nvmlDeviceGetVgpuProcessUtilization = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetVgpuProcessesUtilizationInfo = NULL
 * cdef void* __nvmlVgpuInstanceGetAccountingMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuProcessUtilization = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":355
 * cdef void* __nvmlDeviceGetVgpuInstancesUtilizationInfo = NULL
 * cdef void* __nvmlDeviceGetVgpuProcessUtilization = NULL
 * cdef void* __nvmlDeviceGetVgpuProcessesUtilizationInfo = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceGetAccountingMode = NULL
 * cdef void* __nvmlVgpuInstanceGetAccountingPids = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetVgpuProcessesUtilizationInfo = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":356
 * cdef void* __nvmlDeviceGetVgpuProcessUtilization = NULL
 * cdef void* __nvmlDeviceGetVgpuProcessesUtilizationInfo = NULL
 * cdef void* __nvmlVgpuInstanceGetAccountingMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceGetAccountingPids = NULL
 * cdef void* __nvmlVgpuInstanceGetAccountingStats = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetAccountingMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":357
 * cdef void* __nvmlDeviceGetVgpuProcessesUtilizationInfo = NULL
 * cdef void* __nvmlVgpuInstanceGetAccountingMode = NULL
 * cdef void* __nvmlVgpuInstanceGetAccountingPids = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceGetAccountingStats = NULL
 * cdef void* __nvmlVgpuInstanceClearAccountingPids = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetAccountingPids = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":358
 * cdef void* __nvmlVgpuInstanceGetAccountingMode = NULL
 * cdef void* __nvmlVgpuInstanceGetAccountingPids = NULL
 * cdef void* __nvmlVgpuInstanceGetAccountingStats = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceClearAccountingPids = NULL
 * cdef void* __nvmlVgpuInstanceGetLicenseInfo_v2 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetAccountingStats = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":359
 * cdef void* __nvmlVgpuInstanceGetAccountingPids = NULL
 * cdef void* __nvmlVgpuInstanceGetAccountingStats = NULL
 * cdef void* __nvmlVgpuInstanceClearAccountingPids = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlVgpuInstanceGetLicenseInfo_v2 = NULL
 * cdef void* __nvmlGetExcludedDeviceCount = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceClearAccountingPids = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":360
 * cdef void* __nvmlVgpuInstanceGetAccountingStats = NULL
 * cdef void* __nvmlVgpuInstanceClearAccountingPids = NULL
 * cdef void* __nvmlVgpuInstanceGetLicenseInfo_v2 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGetExcludedDeviceCount = NULL
 * cdef void* __nvmlGetExcludedDeviceInfoByIndex = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlVgpuInstanceGetLicenseInfo_v2 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":361
 * cdef void* __nvmlVgpuInstanceClearAccountingPids = NULL
 * cdef void* __nvmlVgpuInstanceGetLicenseInfo_v2 = NULL
 * cdef void* __nvmlGetExcludedDeviceCount = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGetExcludedDeviceInfoByIndex = NULL
 * cdef void* __nvmlDeviceSetMigMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetExcludedDeviceCount = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":362
 * cdef void* __nvmlVgpuInstanceGetLicenseInfo_v2 = NULL
 * cdef void* __nvmlGetExcludedDeviceCount = NULL
 * cdef void* __nvmlGetExcludedDeviceInfoByIndex = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetMigMode = NULL
 * cdef void* __nvmlDeviceGetMigMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGetExcludedDeviceInfoByIndex = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":363
 * cdef void* __nvmlGetExcludedDeviceCount = NULL
 * cdef void* __nvmlGetExcludedDeviceInfoByIndex = NULL
 * cdef void* __nvmlDeviceSetMigMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetMigMode = NULL
 * cdef void* __nvmlDeviceGetGpuInstanceProfileInfoV = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetMigMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":364
 * cdef void* __nvmlGetExcludedDeviceInfoByIndex = NULL
 * cdef void* __nvmlDeviceSetMigMode = NULL
 * cdef void* __nvmlDeviceGetMigMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetGpuInstanceProfileInfoV = NULL
 * cdef void* __nvmlDeviceGetGpuInstancePossiblePlacements_v2 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMigMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":365
 * cdef void* __nvmlDeviceSetMigMode = NULL
 * cdef void* __nvmlDeviceGetMigMode = NULL
 * cdef void* __nvmlDeviceGetGpuInstanceProfileInfoV = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetGpuInstancePossiblePlacements_v2 = NULL
 * cdef void* __nvmlDeviceGetGpuInstanceRemainingCapacity = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceProfileInfoV = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":366
 * cdef void* __nvmlDeviceGetMigMode = NULL
 * cdef void* __nvmlDeviceGetGpuInstanceProfileInfoV = NULL
 * cdef void* __nvmlDeviceGetGpuInstancePossiblePlacements_v2 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetGpuInstanceRemainingCapacity = NULL
 * cdef void* __nvmlDeviceCreateGpuInstance = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstancePossiblePlacements_v2 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":367
 * cdef void* __nvmlDeviceGetGpuInstanceProfileInfoV = NULL
 * cdef void* __nvmlDeviceGetGpuInstancePossiblePlacements_v2 = NULL
 * cdef void* __nvmlDeviceGetGpuInstanceRemainingCapacity = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceCreateGpuInstance = NULL
 * cdef void* __nvmlDeviceCreateGpuInstanceWithPlacement = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceRemainingCapacity = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":368
 * cdef void* __nvmlDeviceGetGpuInstancePossiblePlacements_v2 = NULL
 * cdef void* __nvmlDeviceGetGpuInstanceRemainingCapacity = NULL
 * cdef void* __nvmlDeviceCreateGpuInstance = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceCreateGpuInstanceWithPlacement = NULL
 * cdef void* __nvmlGpuInstanceDestroy = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceCreateGpuInstance = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":369
 * cdef void* __nvmlDeviceGetGpuInstanceRemainingCapacity = NULL
 * cdef void* __nvmlDeviceCreateGpuInstance = NULL
 * cdef void* __nvmlDeviceCreateGpuInstanceWithPlacement = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGpuInstanceDestroy = NULL
 * cdef void* __nvmlDeviceGetGpuInstances = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceCreateGpuInstanceWithPlacement = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":370
 * cdef void* __nvmlDeviceCreateGpuInstance = NULL
 * cdef void* __nvmlDeviceCreateGpuInstanceWithPlacement = NULL
 * cdef void* __nvmlGpuInstanceDestroy = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetGpuInstances = NULL
 * cdef void* __nvmlDeviceGetGpuInstanceById = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceDestroy = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":371
 * cdef void* __nvmlDeviceCreateGpuInstanceWithPlacement = NULL
 * cdef void* __nvmlGpuInstanceDestroy = NULL
 * cdef void* __nvmlDeviceGetGpuInstances = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetGpuInstanceById = NULL
 * cdef void* __nvmlGpuInstanceGetInfo = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstances = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":372
 * cdef void* __nvmlGpuInstanceDestroy = NULL
 * cdef void* __nvmlDeviceGetGpuInstances = NULL
 * cdef void* __nvmlDeviceGetGpuInstanceById = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGpuInstanceGetInfo = NULL
 * cdef void* __nvmlGpuInstanceGetComputeInstanceProfileInfoV = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceById = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":373
 * cdef void* __nvmlDeviceGetGpuInstances = NULL
 * cdef void* __nvmlDeviceGetGpuInstanceById = NULL
 * cdef void* __nvmlGpuInstanceGetInfo = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGpuInstanceGetComputeInstanceProfileInfoV = NULL
 * cdef void* __nvmlGpuInstanceGetComputeInstanceRemainingCapacity = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetInfo = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":374
 * cdef void* __nvmlDeviceGetGpuInstanceById = NULL
 * cdef void* __nvmlGpuInstanceGetInfo = NULL
 * cdef void* __nvmlGpuInstanceGetComputeInstanceProfileInfoV = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGpuInstanceGetComputeInstanceRemainingCapacity = NULL
 * cdef void* __nvmlGpuInstanceGetComputeInstancePossiblePlacements = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstanceProfileInfoV = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":375
 * cdef void* __nvmlGpuInstanceGetInfo = NULL
 * cdef void* __nvmlGpuInstanceGetComputeInstanceProfileInfoV = NULL
 * cdef void* __nvmlGpuInstanceGetComputeInstanceRemainingCapacity = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGpuInstanceGetComputeInstancePossiblePlacements = NULL
 * cdef void* __nvmlGpuInstanceCreateComputeInstance = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstanceRemainingCapacity = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":376
 * cdef void* __nvmlGpuInstanceGetComputeInstanceProfileInfoV = NULL
 * cdef void* __nvmlGpuInstanceGetComputeInstanceRemainingCapacity = NULL
 * cdef void* __nvmlGpuInstanceGetComputeInstancePossiblePlacements = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGpuInstanceCreateComputeInstance = NULL
 * cdef void* __nvmlGpuInstanceCreateComputeInstanceWithPlacement = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstancePossiblePlacements = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":377
 * cdef void* __nvmlGpuInstanceGetComputeInstanceRemainingCapacity = NULL
 * cdef void* __nvmlGpuInstanceGetComputeInstancePossiblePlacements = NULL
 * cdef void* __nvmlGpuInstanceCreateComputeInstance = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGpuInstanceCreateComputeInstanceWithPlacement = NULL
 * cdef void* __nvmlComputeInstanceDestroy = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceCreateComputeInstance = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":378
 * cdef void* __nvmlGpuInstanceGetComputeInstancePossiblePlacements = NULL
 * cdef void* __nvmlGpuInstanceCreateComputeInstance = NULL
 * cdef void* __nvmlGpuInstanceCreateComputeInstanceWithPlacement = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlComputeInstanceDestroy = NULL
 * cdef void* __nvmlGpuInstanceGetComputeInstances = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceCreateComputeInstanceWithPlacement = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":379
 * cdef void* __nvmlGpuInstanceCreateComputeInstance = NULL
 * cdef void* __nvmlGpuInstanceCreateComputeInstanceWithPlacement = NULL
 * cdef void* __nvmlComputeInstanceDestroy = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGpuInstanceGetComputeInstances = NULL
 * cdef void* __nvmlGpuInstanceGetComputeInstanceById = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlComputeInstanceDestroy = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":380
 * cdef void* __nvmlGpuInstanceCreateComputeInstanceWithPlacement = NULL
 * cdef void* __nvmlComputeInstanceDestroy = NULL
 * cdef void* __nvmlGpuInstanceGetComputeInstances = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGpuInstanceGetComputeInstanceById = NULL
 * cdef void* __nvmlComputeInstanceGetInfo_v2 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstances = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":381
 * cdef void* __nvmlComputeInstanceDestroy = NULL
 * cdef void* __nvmlGpuInstanceGetComputeInstances = NULL
 * cdef void* __nvmlGpuInstanceGetComputeInstanceById = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlComputeInstanceGetInfo_v2 = NULL
 * cdef void* __nvmlDeviceIsMigDeviceHandle = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpuInstanceGetComputeInstanceById = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":382
 * cdef void* __nvmlGpuInstanceGetComputeInstances = NULL
 * cdef void* __nvmlGpuInstanceGetComputeInstanceById = NULL
 * cdef void* __nvmlComputeInstanceGetInfo_v2 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceIsMigDeviceHandle = NULL
 * cdef void* __nvmlDeviceGetGpuInstanceId = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlComputeInstanceGetInfo_v2 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":383
 * cdef void* __nvmlGpuInstanceGetComputeInstanceById = NULL
 * cdef void* __nvmlComputeInstanceGetInfo_v2 = NULL
 * cdef void* __nvmlDeviceIsMigDeviceHandle = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetGpuInstanceId = NULL
 * cdef void* __nvmlDeviceGetComputeInstanceId = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceIsMigDeviceHandle = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":384
 * cdef void* __nvmlComputeInstanceGetInfo_v2 = NULL
 * cdef void* __nvmlDeviceIsMigDeviceHandle = NULL
 * cdef void* __nvmlDeviceGetGpuInstanceId = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetComputeInstanceId = NULL
 * cdef void* __nvmlDeviceGetMaxMigDeviceCount = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceId = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":385
 * cdef void* __nvmlDeviceIsMigDeviceHandle = NULL
 * cdef void* __nvmlDeviceGetGpuInstanceId = NULL
 * cdef void* __nvmlDeviceGetComputeInstanceId = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetMaxMigDeviceCount = NULL
 * cdef void* __nvmlDeviceGetMigDeviceHandleByIndex = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetComputeInstanceId = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":386
 * cdef void* __nvmlDeviceGetGpuInstanceId = NULL
 * cdef void* __nvmlDeviceGetComputeInstanceId = NULL
 * cdef void* __nvmlDeviceGetMaxMigDeviceCount = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetMigDeviceHandleByIndex = NULL
 * cdef void* __nvmlDeviceGetDeviceHandleFromMigDeviceHandle = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMaxMigDeviceCount = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":387
 * cdef void* __nvmlDeviceGetComputeInstanceId = NULL
 * cdef void* __nvmlDeviceGetMaxMigDeviceCount = NULL
 * cdef void* __nvmlDeviceGetMigDeviceHandleByIndex = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetDeviceHandleFromMigDeviceHandle = NULL
 * cdef void* __nvmlGpmSampleGet = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetMigDeviceHandleByIndex = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":388
 * cdef void* __nvmlDeviceGetMaxMigDeviceCount = NULL
 * cdef void* __nvmlDeviceGetMigDeviceHandleByIndex = NULL
 * cdef void* __nvmlDeviceGetDeviceHandleFromMigDeviceHandle = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGpmSampleGet = NULL
 * cdef void* __nvmlGpmMigSampleGet = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetDeviceHandleFromMigDeviceHandle = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":389
 * cdef void* __nvmlDeviceGetMigDeviceHandleByIndex = NULL
 * cdef void* __nvmlDeviceGetDeviceHandleFromMigDeviceHandle = NULL
 * cdef void* __nvmlGpmSampleGet = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGpmMigSampleGet = NULL
 * cdef void* __nvmlGpmQueryDeviceSupport = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmSampleGet = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":390
 * cdef void* __nvmlDeviceGetDeviceHandleFromMigDeviceHandle = NULL
 * cdef void* __nvmlGpmSampleGet = NULL
 * cdef void* __nvmlGpmMigSampleGet = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGpmQueryDeviceSupport = NULL
 * cdef void* __nvmlGpmQueryIfStreamingEnabled = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmMigSampleGet = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":391
 * cdef void* __nvmlGpmSampleGet = NULL
 * cdef void* __nvmlGpmMigSampleGet = NULL
 * cdef void* __nvmlGpmQueryDeviceSupport = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGpmQueryIfStreamingEnabled = NULL
 * cdef void* __nvmlGpmSetStreamingEnabled = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmQueryDeviceSupport = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":392
 * cdef void* __nvmlGpmMigSampleGet = NULL
 * cdef void* __nvmlGpmQueryDeviceSupport = NULL
 * cdef void* __nvmlGpmQueryIfStreamingEnabled = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlGpmSetStreamingEnabled = NULL
 * cdef void* __nvmlDeviceGetCapabilities = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmQueryIfStreamingEnabled = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":393
 * cdef void* __nvmlGpmQueryDeviceSupport = NULL
 * cdef void* __nvmlGpmQueryIfStreamingEnabled = NULL
 * cdef void* __nvmlGpmSetStreamingEnabled = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetCapabilities = NULL
 * cdef void* __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlGpmSetStreamingEnabled = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":394
 * cdef void* __nvmlGpmQueryIfStreamingEnabled = NULL
 * cdef void* __nvmlGpmSetStreamingEnabled = NULL
 * cdef void* __nvmlDeviceGetCapabilities = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles = NULL
 * cdef void* __nvmlDevicePowerSmoothingActivatePresetProfile = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetCapabilities = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":395
 * cdef void* __nvmlGpmSetStreamingEnabled = NULL
 * cdef void* __nvmlDeviceGetCapabilities = NULL
 * cdef void* __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDevicePowerSmoothingActivatePresetProfile = NULL
 * cdef void* __nvmlDevicePowerSmoothingUpdatePresetProfileParam = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceWorkloadPowerProfileClearRequestedProfiles = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":396
 * cdef void* __nvmlDeviceGetCapabilities = NULL
 * cdef void* __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles = NULL
 * cdef void* __nvmlDevicePowerSmoothingActivatePresetProfile = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDevicePowerSmoothingUpdatePresetProfileParam = NULL
 * cdef void* __nvmlDevicePowerSmoothingSetState = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDevicePowerSmoothingActivatePresetProfile = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":397
 * cdef void* __nvmlDeviceWorkloadPowerProfileClearRequestedProfiles = NULL
 * cdef void* __nvmlDevicePowerSmoothingActivatePresetProfile = NULL
 * cdef void* __nvmlDevicePowerSmoothingUpdatePresetProfileParam = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDevicePowerSmoothingSetState = NULL
 * cdef void* __nvmlDeviceGetAddressingMode = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDevicePowerSmoothingUpdatePresetProfileParam = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":398
 * cdef void* __nvmlDevicePowerSmoothingActivatePresetProfile = NULL
 * cdef void* __nvmlDevicePowerSmoothingUpdatePresetProfileParam = NULL
 * cdef void* __nvmlDevicePowerSmoothingSetState = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetAddressingMode = NULL
 * cdef void* __nvmlDeviceGetRepairStatus = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDevicePowerSmoothingSetState = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":399
 * cdef void* __nvmlDevicePowerSmoothingUpdatePresetProfileParam = NULL
 * cdef void* __nvmlDevicePowerSmoothingSetState = NULL
 * cdef void* __nvmlDeviceGetAddressingMode = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetRepairStatus = NULL
 * cdef void* __nvmlDeviceGetPowerMizerMode_v1 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetAddressingMode = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":400
 * cdef void* __nvmlDevicePowerSmoothingSetState = NULL
 * cdef void* __nvmlDeviceGetAddressingMode = NULL
 * cdef void* __nvmlDeviceGetRepairStatus = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetPowerMizerMode_v1 = NULL
 * cdef void* __nvmlDeviceSetPowerMizerMode_v1 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetRepairStatus = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":401
 * cdef void* __nvmlDeviceGetAddressingMode = NULL
 * cdef void* __nvmlDeviceGetRepairStatus = NULL
 * cdef void* __nvmlDeviceGetPowerMizerMode_v1 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetPowerMizerMode_v1 = NULL
 * cdef void* __nvmlDeviceGetPdi = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPowerMizerMode_v1 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":402
 * cdef void* __nvmlDeviceGetRepairStatus = NULL
 * cdef void* __nvmlDeviceGetPowerMizerMode_v1 = NULL
 * cdef void* __nvmlDeviceSetPowerMizerMode_v1 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetPdi = NULL
 * cdef void* __nvmlDeviceSetHostname_v1 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetPowerMizerMode_v1 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":403
 * cdef void* __nvmlDeviceGetPowerMizerMode_v1 = NULL
 * cdef void* __nvmlDeviceSetPowerMizerMode_v1 = NULL
 * cdef void* __nvmlDeviceGetPdi = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceSetHostname_v1 = NULL
 * cdef void* __nvmlDeviceGetHostname_v1 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetPdi = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":404
 * cdef void* __nvmlDeviceSetPowerMizerMode_v1 = NULL
 * cdef void* __nvmlDeviceGetPdi = NULL
 * cdef void* __nvmlDeviceSetHostname_v1 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetHostname_v1 = NULL
 * cdef void* __nvmlDeviceGetNvLinkInfo = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceSetHostname_v1 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":405
 * cdef void* __nvmlDeviceGetPdi = NULL
 * cdef void* __nvmlDeviceSetHostname_v1 = NULL
 * cdef void* __nvmlDeviceGetHostname_v1 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetNvLinkInfo = NULL
 * cdef void* __nvmlDeviceReadWritePRM_v1 = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetHostname_v1 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":406
 * cdef void* __nvmlDeviceSetHostname_v1 = NULL
 * cdef void* __nvmlDeviceGetHostname_v1 = NULL
 * cdef void* __nvmlDeviceGetNvLinkInfo = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceReadWritePRM_v1 = NULL
 * cdef void* __nvmlDeviceGetGpuInstanceProfileInfoByIdV = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetNvLinkInfo = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":407
 * cdef void* __nvmlDeviceGetHostname_v1 = NULL
 * cdef void* __nvmlDeviceGetNvLinkInfo = NULL
 * cdef void* __nvmlDeviceReadWritePRM_v1 = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetGpuInstanceProfileInfoByIdV = NULL
 * cdef void* __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts = NULL
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceReadWritePRM_v1 = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":408
 * cdef void* __nvmlDeviceGetNvLinkInfo = NULL
 * cdef void* __nvmlDeviceReadWritePRM_v1 = NULL
 * cdef void* __nvmlDeviceGetGpuInstanceProfileInfoByIdV = NULL             # <<<<<<<<<<<<<<
 * cdef void* __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts = NULL
 * 
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetGpuInstanceProfileInfoByIdV = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":409
 * cdef void* __nvmlDeviceReadWritePRM_v1 = NULL
 * cdef void* __nvmlDeviceGetGpuInstanceProfileInfoByIdV = NULL
 * cdef void* __nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts = NULL             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __pyx_v_4cuda_8bindings_9_internal_5_nvml___nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts = NULL;

  /* "cuda/bindings/_internal/_nvml.pyx":2866
 * 
 * 
 * cdef dict func_ptrs = None             # <<<<<<<<<<<<<<
 * 
 * 
*/
  __Pyx_INCREF(Py_None);
  __Pyx_XGOTREF(__pyx_v_4cuda_8bindings_9_internal_5_nvml_func_ptrs);
  __Pyx_DECREF_SET(__pyx_v_4cuda_8bindings_9_internal_5_nvml_func_ptrs, ((PyObject*)Py_None));
  __Pyx_GIVEREF(Py_None);

  /* "cuda/bindings/_internal/_nvml.pyx":2869
 * 
 * 
 * cpdef dict _inspect_function_pointers():             # <<<<<<<<<<<<<<
 *     global func_ptrs
 *     if func_ptrs is not None:
*/
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4cuda_8bindings_9_internal_5_nvml_1_inspect_function_pointers, 0, __pyx_mstate_global->__pyx_n_u_inspect_function_pointers, NULL, __pyx_mstate_global->__pyx_n_u_cuda_bindings__internal__nvml, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2869, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2);
  #endif
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_inspect_function_pointers, __pyx_t_2) < (0)) __PYX_ERR(0, 2869, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":3922
 * 
 * 
 * cpdef _inspect_function_pointer(str name):             # <<<<<<<<<<<<<<
 *     global func_ptrs
 *     if func_ptrs is None:
*/
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4cuda_8bindings_9_internal_5_nvml_3_inspect_function_pointer, 0, __pyx_mstate_global->__pyx_n_u_inspect_function_pointer, NULL, __pyx_mstate_global->__pyx_n_u_cuda_bindings__internal__nvml, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[1])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3922, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2);
  #endif
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_inspect_function_pointer, __pyx_t_2) < (0)) __PYX_ERR(0, 3922, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "cuda/bindings/_internal/_nvml.pyx":1
 * # SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.             # <<<<<<<<<<<<<<
 * #
 * # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
*/
  __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_test, __pyx_t_2) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /*--- Wrapped vars code ---*/

  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  if (__pyx_m) {
    if (__pyx_mstate->__pyx_d && stringtab_initialized) {
      __Pyx_AddTraceback("init cuda.bindings._internal._nvml", __pyx_clineno, __pyx_lineno, __pyx_filename);
    }
    #if !CYTHON_USE_MODULE_STATE
    Py_CLEAR(__pyx_m);
    #else
    Py_DECREF(__pyx_m);
    if (pystate_addmodule_run) {
      PyObject *tp, *value, *tb;
      PyErr_Fetch(&tp, &value, &tb);
      PyState_RemoveModule(&__pyx_moduledef);
      PyErr_Restore(tp, value, tb);
    }
    #endif
  } else if (!PyErr_Occurred()) {
    PyErr_SetString(PyExc_ImportError, "init cuda.bindings._internal._nvml");
  }
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  #if CYTHON_PEP489_MULTI_PHASE_INIT
  return (__pyx_m != NULL) ? 0 : -1;
  #else
  return __pyx_m;
  #endif
}
/* #### Code section: pystring_table ### */
/* #### Code section: cached_builtins ### */

static int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate) {
  CYTHON_UNUSED_VAR(__pyx_mstate);

  /* Cached unbound methods */
  __pyx_mstate->__pyx_umethod_PyDict_Type_items.type = (PyObject*)&PyDict_Type;
  __pyx_mstate->__pyx_umethod_PyDict_Type_items.method_name = &__pyx_mstate->__pyx_n_u_items;
  __pyx_mstate->__pyx_umethod_PyDict_Type_pop.type = (PyObject*)&PyDict_Type;
  __pyx_mstate->__pyx_umethod_PyDict_Type_pop.method_name = &__pyx_mstate->__pyx_n_u_pop;
  __pyx_mstate->__pyx_umethod_PyDict_Type_values.type = (PyObject*)&PyDict_Type;
  __pyx_mstate->__pyx_umethod_PyDict_Type_values.method_name = &__pyx_mstate->__pyx_n_u_values;
  return 0;
}
/* #### Code section: cached_constants ### */

static int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate) {
  __Pyx_RefNannyDeclarations
  CYTHON_UNUSED_VAR(__pyx_mstate);
  __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);

  /* "cuda/bindings/_internal/_nvml.pyx":420
 *     cdef void* handle = NULL
 * 
 *     with gil, __symbol_lock:             # <<<<<<<<<<<<<<
 *         # Recheck the flag after obtaining the locks
 *         if __py_nvml_init:
*/
  __pyx_mstate_global->__pyx_tuple[0] = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_mstate_global->__pyx_tuple[0])) __PYX_ERR(0, 420, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[0]);
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[0]);
  #if CYTHON_IMMORTAL_CONSTANTS
  {
    PyObject **table = __pyx_mstate->__pyx_tuple;
    for (Py_ssize_t i=0; i<1; ++i) {
      #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
      Py_SET_REFCNT(table[i], _Py_IMMORTAL_REFCNT_LOCAL);
      #else
      Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT);
      #endif
    }
  }
  #endif
  __Pyx_RefNannyFinishContext();
  return 0;
  __pyx_L1_error:;
  __Pyx_RefNannyFinishContext();
  return -1;
}
/* #### Code section: init_constants ### */

static int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate) {
  CYTHON_UNUSED_VAR(__pyx_mstate);
  {
    const struct { const unsigned int length: 15; } index[] = {{1},{26},{54},{179},{1},{1},{8},{39},{33},{29},{48},{51},{51},{48},{51},{48},{49},{62},{44},{49},{49},{50},{49},{55},{46},{58},{49},{47},{48},{59},{49},{42},{50},{40},{49},{42},{47},{47},{47},{44},{47},{40},{52},{46},{61},{57},{66},{60},{66},{45},{43},{57},{46},{49},{56},{57},{52},{60},{52},{53},{49},{66},{48},{46},{53},{49},{53},{42},{50},{50},{47},{53},{53},{46},{43},{54},{46},{43},{46},{46},{55},{49},{49},{58},{67},{63},{47},{50},{48},{62},{59},{51},{60},{53},{50},{51},{54},{49},{47},{48},{47},{46},{40},{63},{54},{49},{41},{49},{51},{64},{52},{47},{56},{52},{56},{51},{55},{49},{49},{49},{53},{48},{57},{42},{54},{49},{46},{43},{48},{39},{42},{46},{45},{51},{53},{45},{57},{57},{46},{48},{47},{57},{49},{44},{45},{45},{51},{52},{44},{49},{38},{51},{51},{50},{53},{47},{55},{66},{62},{52},{46},{45},{45},{53},{59},{47},{47},{47},{50},{60},{55},{59},{42},{41},{53},{70},{62},{54},{58},{56},{61},{49},{49},{47},{55},{50},{57},{54},{49},{57},{39},{51},{47},{51},{56},{63},{47},{57},{63},{51},{53},{60},{62},{62},{50},{53},{49},{48},{43},{67},{70},{54},{47},{47},{46},{44},{52},{55},{56},{49},{49},{59},{47},{46},{64},{46},{66},{53},{53},{46},{42},{51},{46},{50},{51},{46},{53},{42},{64},{47},{50},{55},{58},{52},{55},{51},{56},{53},{53},{47},{74},{37},{40},{38},{41},{48},{54},{46},{51},{40},{41},{47},{52},{38},{48},{58},{71},{44},{51},{67},{72},{73},{56},{59},{54},{44},{61},{58},{56},{67},{61},{58},{39},{33},{40},{34},{46},{44},{44},{58},{51},{60},{70},{54},{52},{55},{47},{48},{45},{46},{47},{46},{49},{46},{60},{70},{47},{38},{40},{45},{46},{41},{40},{44},{41},{41},{57},{55},{55},{56},{48},{56},{53},{56},{49},{52},{48},{55},{54},{49},{54},{55},{49},{49},{52},{57},{45},{45},{56},{45},{56},{45},{49},{42},{45},{50},{51},{52},{57},{48},{44},{49},{54},{63},{41},{52},{47},{21},{4},{17},{20},{18},{18},{29},{15},{9},{8},{8},{25},{26},{13},{5},{23},{8},{10},{4},{8},{28},{31},{31},{28},{31},{28},{42},{29},{24},{29},{35},{29},{29},{30},{26},{38},{29},{27},{28},{39},{29},{22},{30},{20},{29},{22},{27},{27},{27},{24},{27},{20},{32},{26},{41},{46},{40},{37},{46},{25},{23},{37},{26},{29},{36},{37},{32},{32},{40},{33},{29},{46},{28},{26},{33},{29},{33},{22},{30},{30},{27},{33},{33},{26},{23},{34},{26},{23},{26},{26},{35},{29},{29},{30},{28},{47},{38},{42},{43},{27},{39},{31},{40},{30},{33},{31},{34},{29},{28},{27},{27},{26},{20},{43},{34},{29},{21},{29},{31},{44},{32},{27},{36},{32},{36},{31},{35},{29},{29},{29},{33},{28},{37},{22},{34},{29},{26},{23},{28},{19},{22},{26},{25},{31},{33},{25},{37},{37},{26},{28},{27},{37},{29},{24},{25},{25},{31},{32},{24},{29},{18},{31},{31},{30},{33},{27},{42},{35},{46},{32},{26},{25},{25},{33},{39},{27},{27},{40},{27},{30},{35},{39},{22},{21},{33},{50},{42},{34},{38},{36},{41},{29},{29},{35},{27},{30},{37},{34},{29},{37},{19},{31},{27},{31},{36},{43},{27},{37},{43},{40},{31},{33},{42},{42},{30},{33},{29},{28},{23},{47},{34},{50},{27},{27},{26},{24},{32},{35},{36},{29},{29},{39},{27},{26},{44},{26},{46},{33},{33},{26},{22},{31},{26},{30},{31},{26},{33},{22},{44},{27},{30},{35},{38},{32},{35},{31},{36},{33},{33},{27},{54},{17},{20},{18},{21},{28},{34},{26},{31},{20},{21},{27},{32},{18},{28},{38},{51},{24},{31},{47},{52},{53},{36},{39},{34},{24},{41},{38},{36},{47},{41},{38},{19},{13},{20},{14},{26},{24},{24},{38},{40},{50},{34},{31},{32},{35},{27},{28},{25},{26},{27},{26},{29},{26},{40},{50},{27},{18},{20},{25},{26},{21},{20},{24},{21},{21},{37},{35},{35},{36},{28},{36},{36},{33},{32},{29},{28},{35},{34},{29},{35},{34},{29},{29},{32},{37},{25},{25},{36},{25},{36},{25},{29},{22},{25},{30},{31},{32},{37},{28},{24},{34},{43},{29},{21},{32},{27},{3},{12},{12},{12},{10},{8},{9},{5},{6},{25166},{31},{5244}};
    #if (CYTHON_COMPRESS_STRINGS) == 2 /* compression: bz2 (6754 bytes) */
const char* const cstring = "BZh91AY&SYQ\203\306n\000\013\235\377\377w\370\356\236\177\377\377\373\277\377\377\360\277\377\377\360@@@@@@@@@@@@@\000`*}`gy\367m\357\221\274\275\232\033V\230h\r\265\032\363\216\273x\214v\332q;9\335\357H\274\000\014w\233\r\\\304\000\331\021\306\344\030\335\312\265\256\\\002\024\002B\216\222\222\030\000\000\240f\200\305\233\014\344\231\247\035\035M\016t\320\320\327\306<\000jzL\211\212z\251\3552\243i\r\001\243@m@h\000\000\000\000\000\320\320\000\000\032b\010\2114\022\236\2024\000d\320h\3204\000\000\000\000\006\215\000\000\000I%@\000\000\0322\000\000\007\250\006\200\000\000\00044i\221\350\203 \022z\251)\244\323E<\246\247\243\020\324\3325?P\21524\032\006\010\003\t\2402\0320\232h\006\206\200\320D\210\204\002\246\310\200jy@\3651\251\223M\003\0104h\031\000\006\200\0322\003A\2435\004I M\t\210\001\244\032`\246\251\373Jl\230\231$z\236\210\000\000\000\000\000=!\350\233\334\254\254\312@\262\"\"\210\222\004\270\r\257\303\277\354\363\351v`WD\217\036\362\317Q\n\3573\330\255\226A\345\264Q\363)\031\246\002\321\227\026H\375\206\252&\2755\227m\027Z\234\261\307,)\277Q*\355\343\322\252\376\035~\036\352\274\017Q=Y\025\334G3\336\347\216\3526+\277\271\337Y\273\"\370B\373\036\2733\217SV\356\203\r\216\331O\216\331\2200\243L \371]\376\037I\212\354\327\246\234\223\006\027\013\231G\270\214a\020I3\320\262\373\033\324\204fJ\361\235O\220\230\261+s\334\376\342\025uM\036Z\007|\241\275-x\320\251\227\235\270\265n\207\215\326\244\021(7\336\264zPPB\306:\016{\325\340\346\303\321\342\253r-\342\357>\230\036_\206T\313\021X\326M\261\265\0266\2426\010\2516\003lU\203cc\006\031\220\341\317\244$!\362L\251d\271l\314\3479\206C\231\231\"`\346'\327\300x\024Q\"\252$\223\274\212\211p\262(\242x\024Q>\017\000\273\3247\206O6U\2222\034%2\251\221*\252\0255\345\206\005\262\014\220qG!\3103\373\3077/:(\277\323\004\220S\276Z\327%I\255\275\326\253\215\305\265qQk\215mDl\210H\244\010\306\253\267\354v\365\020\357\377\277`M\306\301!\236\035\317\265\374\327^\212\211\343C\224\221$$\004\220E\220\007N\211\335\341\235\021\316\320\242""\301\004Vv\235\025>u\303\364*\243\320\236\013\337:<\257rU@\253P`\321A\237\031\227\250/\300J\305#a\275\030[\270\202\344\311\237 J\3426\335k\\\203\n_\206\222\030\224\204\270$V\024\200\231\212\031\340\225\205\360\335A5i&\026\263\246\254(Gv/\021\000xt\013\260\215\370\222<\363\350K}j&c]\024u\256\246.m\241\336\351\3652\351\342VGmT\325F\327\014^xn\371\221\262qU\023\334h\366X\341\240x\330cd]\t\257\022\212\027J\313o\231D\226H'\223\n\270sF\335\266\300\266s-\031\026\273F\030\303\203\n%\367?t\260*':\267\020Icm\266\223V\221\255C-5#6\312KRki\266\224\250Zj\315iA\000\255\027\\gq\\Ygua~H\000o\362\247_\242FC\262vY\n\220\252\250\306\024a\000\360\375jR\n)\367\"\243B\363\271\t,\217;\226\306J\242\321RF(\210\266\275N\"\325\316si+3l\006\215\244FB@$\r\367\240\340\212\001\001{\335@\272\205\324\336~\332\257-\257*\242\250\330\324\010b*1B^.J\240\254j\242\321W%\2712ch\305\222H\250\220\241Fe\n\223\215\304\221\030ID\333B\022\026 {\221\036\256\256\327z\316\347\220bT\237STL\336,@\367\304\367\177\263\276\006w!z;\216\036**N(T*\245\213H\225\033\020d=\002U\302\352h\002v\022\000\376\340\330ZB\013=\231\370\345\210\036\250\033 \364\001\255\002\223X\272\335v\007\203\267\234|\207\366-\003\307\004\003ob\3677\345\\\352\334[\333\365n\221\334\327\036\255\333v\352\234\207\333\254&\355\322\006\352\242\235\324\024t\323h\026\225*2ITUUI\210\352\217\367\000mt\352\222\\5[_:\020.1\222;\237\026\233p\276p6vCpn`I! \007^\035x\200z\227\310\345\254\262\352K\262\356K\271S|\222`\227S\221\030F\020\356y\232\231\017\021\330-\202\030\367\211%\274j\311%\201s\315\223-P]\014a\341v!\361\344\252F\344\222]\322Gxw\336\363\025\334j\3541\214\031\032\nnn\255-\313\233\375z\2075\271\272c\033c\033\314\334\232\230\354\362\002\234nv.\022\020:i\031\315\242\246\220LI\"Hi\240\320\220\030\211#\315\357\366\275\260}\330&@4\035\335A\000;=rIJ*\005.XF\302\336\323\000\000\346\352\335\200\211\227\036\316[z\230\340r\320\027:\014m\217jb\252\252\252\232q\317\303\321\341\324I6m\324\030/.d\201\010\302\320\262\003#\204)\247\257\247\"H\224;\021\323G&0\336\303\272""\264\220\222I\t\022.[\035\206\374`\343E\203\016A\327m\220;0\220*\005E40w\005\325\240\222}\303\356\177\023d\r\301\213\301\377 \205\220\260\265\025[\307,\262\3137l\265r\312\2673W1\214@7\214@\266\010$b\266\301\002\230\010\225\225h\rj\231nf\332\274Z\327%\213u\202\024\301\2628\030\212F)cB\024\037\t\201\226\360\313\314\226\332)\0060\031\0306\027J\026!\022=o\013L\270\311(j\267\270\240p\222I\000\"h\361z\000a\255B\234 \303\240\316\031@\252\245\252\256P3\266q\223VUt\2722]u\032\341\315\324d\316h\221\016P\354\275Z;:S##\210\361\234\265\306\307\216\330\226P\034)\276\234\341:Q\342tu&\352%$\035P,r;\031\004\202A\255UkW\212\325\324\253\252\225\214\230\031E\353*\315\234\022\"Yib\342e\200\2423\310\275\037\351\356\357\351\327]u\327]f][\327nr\336\236\"\003P\025T\313Z\"##-\000\001\264\001\023\330\347%\213m\316q\315\271\256s\256\355\326o\332\3714x\010\035\250\367\3408\037\242\010}\277\232\331\316\014\3408\202\307\004^x\350+\233\223q\2717\314\333sR\231h\313y7O'gy\t$\2402\366\317M\325\371\327\034\253n\321\3551\216\264\016\351$\201\3447\r!\250\274%\014c\201\316\323Pl\332\3067I\002@\345w\365\0230\222\020\240\210\340A\216b<\316O\256\354G\211\177\367\301\3279r$\\\323!\212\222)]\242\362\255\345KV]MI\014M@\"\226Z/*\336T\265e\324\324\220\304\325*\027B\303\"\220\324D)\004\23797\034G!\037\264\020\216Q\220\223S\317\340\351\307\207\362\030\241 i\222H\361E\220a\000a\031\370\201\016,[\235\240\322\354w!\377R\366}\236\037\204\016\227VO\225\255.!\210\205\215\350`\307\221\315\322\336\267\264\355\336HHS\213\271$\264.3\304C6;0u\214<p{\301m\346YK\231#\"a\325\n\033m\022\250#q\221\266\243\325\3444\336\007f\213v\204*\252I$\251cg\007\"\323R\366\014>Hk\273o\205{\033\266o\233z\265\352\213\324\3759\272n\023'9\306\351\0377z\366\007\003\230\365\261\345\036\005\326X\222A\247\2149\006\315\235\324\342\020\263\262\327\276\304-\311\350\r!e\212\213\343\201eN,p1\366\275\025\343\275\257@xu\271w\356\273\353n\355\345\273\203\317\364\010@2oC\234\035\303\007E\2001`\221\202T\222@w\272\333b\033\330\345u\201w$\222G9\277:\313\272\273""\n\227W\025\340<\311P\222\020\022Q\003#\326\030/\257Iy\026A\352;Fe\330\274*\036\014\r\306bb\360\250\3118\024s\325`6h\300\321\352@\355\313)\"\222I$\220D\243\350\362\372\\\313\2325USF\246X\343\330\002O\232\311'G\227\020\310\005\261\235H\201>%\273\344\213\2025%S\317cFL\201*\017u\310\344\210x\270\252\252\260\020\273\276\305\335CM\361\223\245V\016\357\234\003\337n?\032\251R\202T\331\230n\nA\263\001\263\245\303>\232I%=X\257\023\356\2213\"H\021\270\264,]\261{\362#\274\353\322P\323~\214\030\231\226<\365\026+\222#\267\2628\347S\241\352\253\325\356$Ue\212\027\213CCZ\360\360\273\357\017\016u\233\341w\200\036[yo71\212\312\332\270\253s&Ji\024\231(\222\242\222\320U\200\300\341c HX\352jP\325R\350o\204\204\246\361\341c\226O\305\352\020\372>\204<\021\360\003\275<=#\370\004>\341\r\234w9\327\220\342\374\334Z\007-\241\256Q\250\311\215\010\232\244\320 \0046Va\231E\337\300<\352\232\276o\n\311\332\347G\2375\2050*\325\320\254B\374\356\023\221\322A\223\225\232\371\005@kc\261m\014\254\333\001+\210\333u\255r\013R\3744\220\271HK\202Eh\32131C<\022\260\277\033DgM\202\332\316\233(\024\266/\274\200(/J\221+\321\r)\234\250\272jBTl\216\207\255u1sm\016\367O\251\227O\022\262;j\246\2526\270b\363\303w\314\215\234J\250\236\343'\262\307\r\003\306\303\033\225iMx\2241t\254\266\371\224Id\203\312\001W\003s\335\3356\037\007[\300\347w\207\251\026N\345\030`ZjT2_\307\032Q\314gG\000n\200RI$\222\010$\222I$\200\000\000\000B\000\000\022\000\000\000\000\000\001 \000\000\000\000\004\200\000\000\000\000\000\000\000\000\000\000\000\000\000\004\200\000\022\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000H\000\000\000\000$\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000B\003\311\350\271+ko\035\344\3668x\365\353x\372\375\267[\267=q8\326\032\0040\t\362YP\244\3715\022Fj\246A\326O\224h\\\273\222G%\206\274\242\210`\2426Quj\031\004\234J\244\004\033(%\321\224\036)\300\323\264\207D\201\361\0134\311F1Pb|\222\242\310\002\262\252\217\0343\201j\247DE=\220\302\250\276)\313""\000\242\003 \214&\220I\020\220f\325\264\270\262\023Z\275\261\207\216\272\t\230\227\004nf\007Q\261]\270\222\004\206\263\227^pjb\266\362\367\360\323I\236Pq\212\356\346\325\207\214dj\205=j\347J\303\323\031\032\241\234,\004\202I\033\303\001zZ}\2149\"o\0200\n\\\301\203\025\373\003\207b\255\330+\327\2505\262\344~\333\t\230\372\216\006\235J\331\014\334CH\340\261\322\037r\360\006N\003\200X\343x\220\333J{3\001\366\017\265\241\315\263\000\246&\321\270\003\267!\003\241]j\010kb\241\006\010\206\303\350\303\376\n\372\372\273\337\236\200\345\362\267-\236K\305\037\233\250\207;\226\360~#s\366;\203\006\303\274\337\037\213\347\325\255\036\354Q\3458b\324$J\210T$H\014\303\364G\310)\230\303\230\205BD*%z\316\361\243y\253\317\257\307\331%xs\220W9\271\254\200\002Wje\\\344\025\323\311\335\266\273\266\257\n\346\207R<f\325\0230~'\312|\244I\362%5\n\213#RI$\221%Q\371\326\242;\307\267WGio \317Z\014\204\204\"{Ow\203\370.\033\341!$b\001\204\r\017u\301\322<\357\214\006\301\000\366\204\256Ro\314|\305|\177\245\255\276\215U\333\334b\355\226@m\226l\262\320\000\000\006\325\231\225\233l\005Z\000\000\000\330\000+33X\ri\232\251e\251f\264\313S6\2533j\314\266\263\000\264\005P\000\001\251f\331\251\231\263Se\245\245\263R\312\254\313m\000\006Y\261\245\231\305\304\271\316$H\310J-\033X\321\243m\240\020\"R\215\020PCMQ\027\274\3536\333\226\335b5\244\320V%\303\210\372\320<\372\363\201vO1A\323Uv\020$E7;M\036\345\323\210\r\362I(\014\303g5\301\270\000\311\2446\006L \221(\025\022\020\332\226\200A\321\365i\353\327v@a\227\300\240\217V\267WM\222\223\024! \242\325J\204\230\224\342\350\242\026\221\316j\240\211P$r\344\250HHL\344(C\014C\260\021\003L\206\213n\031x\225\t3)\315\321D-<\315([H\310\310u\013\255\271\035\017;V\0161\025\275|)\rpW\\C\271\241\021M\001\314\022\346\303\243\n\025\305\326\026\300/\201 M\\\005\220\310,\013p\362\345\363h\335\266\353HzeNi\344\205\370}6\2640\006\222\004I\35271F\006\210\256\233\312\232\005\032!\222A\321\336\374\2628\367U\263'\234[\333|\364B8\305\216\323'kM\035\"B\0331\010\236\226\230!\220\264""\221\331CY\262:oY\314\314]B\021\314\010\027\010\306\200J\333\253\201\261\320b\2051\302\221\024\266\nI$\tki\232\3253`SZe\266f\266\272nK\025\232\233k\002\226\255\231U\253\253\253l0m\002\367UBUVh\253\252\260w\024\333\014\020\220\273\220\316\352\31590\"a\200\370J\024\353i\302\352J\252\222\252\244\"\021\313\032\250\020\030\001C\005\214x\014WF\370\347\010q04(\310\212E\313(\2325Y\033\203n\346;\234\233\200\325\300v\207\r\336\030\356\242IG#q\t$\222R\033\332\256\\\215y\\m\274\332\021\274X\3552v\264\321\322$!\263\020\211\354\264\301\014\205\244\216\312\032\315\221\331\275\017\026\237U\321\20448G\231D\204Cf\246XbB5-\222KJ\013A\211bfKnXjP\"\000\223\255\222\333\025\270\255\305\252(\244\333\313-\322\313\240\300\222I$\231x\272>\206\206\206\234\304=\315\303p\001\340\0322z\337\224\363<\032\2071\225I\300:\322v\025\000\224\220)\253\036\350\020\030\037/\251mL\004Cd \362`[\275\321m\335\204\201\004\324\013\212\340&pSf\260t\322\335}\236XH\034\3134\236A\210\201\026j\2170\324\361ZH\014\024\312\001\204=\005\0145\301\362\270\200}hd/ \346\272\351\022(\020z\252\244H\210\215\351\252\363\355v\245^\355\346\335\374\341\273\367U\357\200mB\345\265\215lx\202\301\342\300 \247\224nBPb\005\336\341\260\n\t\022D\261\240\331\252`\315\001\331\3067\324\211\332\256c\245\010\305\014\004\247\300x\303\025\016\310\036 \246\003\356\016\307\260N\235\305x\373w\345\371]\331&\265A\2224J\325\r^\2645\014\341$\354U\001q\"$\220H$\023\273/{\027\275\354j\031\302Ia^\003\247t$\345$\232\007\027\035\274\300\331\0069\212\320n\000\216X\004\010\027=\252\366\355\341|\024\360\345r\347\034\202\210\212\250\013h\255\020mD\032\300\220Ve\240\242\315\225ffm\2103-\021\021\210\255L\257\021\261\300Z\233+W\\\016b\r\265\020j\306 \255\263\220\345\2106\324\315\314\333p@\032\324\006\260R\200Z\271e\255s\024\333D\033Z\002\301\000[I\000k\002\022H1h(\252 ]\324\214\013v\000b\245\r\340P\250\272u\276c\020T\026\200>\377o\343\003\303\323\304\nh\350\007\347nc\334/X\362\217\346\000\\\241\322\032\034\321|\276l\200.\025\003xkB\221\274\025\022\345\r\274\274\"(""\235\306\227\035$I$F\203-\305\311A\202\254\315\253\341\347E\362m\337M\265@\021\r.\326\006\345\311\004\016 z\342*\306I\"\202\030\206\203)\"H\336\3138\260\r\257\23220\203\300\306\244F\035m\002\327\200M\214\026\340\270/P\267[0T\362\267\356#s\0242\263\230\372\033\303@\330\017\000\353g0w \240\275b\307{\327\212\031\201\\6\0130/\346\007\344\206\324_R\353\330\243\265\356D\334\202\006\326\356\200\244_\001B\302'\223\230\240\234`>{h\007\221\320=\001<\332M/&G thl\365\017H\356\260H\310H\r\220\271(\016\027+9\027\005\314\t\250t\200`\016\320\031\005\220 5zw\242\367\265~r\325\267\301\353<7\263\346\364\240\21114\251\221\214\331[kIT\246\25320\305\201\030F@x]\201\2640\r\230)\314>`5\"\242j\352\007jj\036U\350\016P\325\006D\326\213P}v\013B\300J\252\252\252\256ghu\365\003\316\251\177%\022\230\325\022\212\251)\241\252*\244\246\017\022\006 \005\000>e\016\205\346\321\364\247\322\211\360\037\200i\257>\326R\323\021\246\274msk\225L\334\262\334WH@C-\207T*n\204\001;\240\000\013L@\214UB\202\002\334\004\020\000\260A\005\010\\\207b\257\221\356r,\036\200q\310\\V'\2378\310\211\036\020\247\001\355\272I\025\3022\010V\0130;\3042\256S@\212\231\311$;\236}\030\001\300\353\307\270C \000\270\010.\220\n\366\007\236\302\001\222\231\262\374\r@\0235\260;\233\335S\002\343\262\212-k\200\246\346\254\334\215\003l\021#a\207\254#\315\220r\021\"\021\200M\022\335\n+K|\307\302\324vF.\007\323\330\343$\006\004d\027\000\016\206\224\260\016\341\021\021\263\351\344|\252b\"\\\021C\020\r\315\202\r\357\032Q\304\024\363\340\357\200\250\231\225\007\000E\n\006*\367\330\323b0h @$\004\314\003\000Qd\214\226\201\357Q\275[\236\016\250z\027jj\301A\rC\004W\326\300\273B\217\341\010\206\002\250\227MTQ\n\342\000\261\024M\233p+<\261\016QQ|k\312\016\315tU7(\201lF\313b\252wP\340\010a\200F\321\023\202\034)\334\212\211\247M\266a\244Y\006Gx\273 \201\261`n\004\000\203\214Ha\020*\211(Q\245\\@B\301J\306\3513\025\253\272\257\036w;\271\256q\3138\345\215\341x\355\217\177\316\033|\251\031\226\341\021\020A\021\021\021\021\021\021\021\021\021\021\004b\"\"""\"\"\014DDDDDDDDDDDA\210\210\210\210\210\210\210\210\210\210\203\021\021\021\021\021\021\021\021\021\021\021\021\021\021\021\021\021\021\021\021\021\021\021\021\021\021\021\021\020b\"\"\" \304DDDDDDDDDDDDDDDDDDD!\021\021\021\021\021\021\021\021\021\021\021\021\021\021\021\021\021\021\021\020\202\256h\332\262km-n\001\021\316&\256\021\021\021\021\01001\021\021\021\021\021\020\241\r\312\246\333\204\025( \205\211\371a\"\241\"\010{Q=\230*\237\236/n\366\362\005\311\316r\3479s\234\270\210\210\210\210\210\210\2168\210\206\343\204DDD\003\2334W\010\210\210\210\210\210\210\210\210\210\210\210\205\315\251\032\256\021\021\021\021\021\004b!\271\2120\271\354\376\206\325\354\266\247\273\350\346\256\265\251\350O\254\037o@\255\204*+\001\210\007\255W\266*\374\030\200\024+\025\353\340\305\027\020 \006a\222\236\216\323\346\274\017b\207Pw\300\312\236_[\240\006\366\324G\255Gh\002\251\315\200.\300\210\245\312\246\266\234\210HHHHm\002\341\016\020qSM\301\357SN\251\004;\030%i\344s}\241B9\016\016\201\0034\003S\264w>\340\210E\326\212\211\314l\037\244\013[!\314m\212\2375\235~\270\242\211\265\027`\001\027\304;@03ow\272\303j\243\363\264\340<\350q\007\245\333\020\035!\345\373\372\303\344>/\036Q\221D$\002A3:\036\020\002\007\316\206J\027\207\343u\205b\353`\336\001\244C\270\322\247F\032d\222E\035\013\342+sFFhNoj\267\216\337\237\251Jf\232U6f\246\246\264\266\314\253+,\261\2652\305\214\242R\224\324\251CR\331l\265\246\312\326\220\306\020\221\220\213\031\016\326\360A\325\303\310\353\017O(P\037\253\361\375O\227\306z$\225)\204*\202\352\245\312\262W\253u\367|]\311\331R\241CR\226\000\322\005\r,`%AR<\206\202\330\210\361\304\021\271\244\255\215\202\374\337\237f\367\335\347\303\335\332\232\352\353\344`\365\201\316\344\007S\025`f\375A\2126\030\305#\007\247P\357\0006\006\3015/e\026[\006nYG\274iC\2744\2725\211K\020\324\036\300\210l\r\241C\367\234\270\325u\201\220D6\217\000\250\266g\002\213@\031\001x\033\030\233@\016\307\007sq\200\375N\341\260\213\273\322U\272\222@F\007S\005h8\201\032B\014H\301\rg\311C\246\330\206eN""\367?R\362i/:\\*\274o^\261\t\224\022d\200\202F\376\014\255\221A\212E-\0022v\215\t>{\354.m\264\032B\371,\231\010\211/\226\311._\000\317\007\227\027\024\032A\206.L\334\252\334S\251\234p\231\340\n\211Zb\215^-\206\345vz\364q;\016\000-\264(J\n\006\007F\336\033\363wt\\\251\323\220\311\220\210\222\373X`\271|\203=\207\265\305\305\006\220`K&\231Kaa&\247\223]\273}m\016\205\r\005\010\302\340i\006\201\010\301 \221\006a\353B\214\333\036\370\006E\316\240\017h\036K+A\351\236\2509b\336\241\210\344\202\004\r\2420 \204\006\017\217\215\3578\371\320\304\346\205\270\000\214\027\304\030\tx\002a\303\206\005\324 `\020\003\251h.B\007\255P/F\313\003Ss\203\r\320\034Z9\333\235\226\317\016\t4V\004>\274\3566\335W\324)\341\005\026\353\005B)lh\262m\006\343q\255\033I\270\343E\222\202#\\W\tl\314i \251\3168\\\322\271\316i#D\214\314\246\360[\262\004D\010\017w\201\221\275\310\331\252\262\232H-2`\030\004\223\0044beE\223Y\245Rm\215\211\002\232QQRm\032\243ck\026\306\322Q\264\024lme\315V\3631\026\357\301\033 \324%\005\tT\322\253\226\0025\001\214\004;\230\305j\202:j\362\252\271V[[\266Z\306B\005\311%J\0243l\211\"R\010\352\301\250\010\004\035\3249\272Q\202\323\024\244\rb\203LU5\010\000\000Ly\206qHdg\0220\325YM$7Z\024\025\215&@\275B\315%\201p\221\221\340\243b\033\307@@\016\362\210@\221i\nU/\203\221C\02444\322\0240`DR\014\007F\333\033dR0\010\202P\330M\215\341\262\021\240\213\030\306\r\004sJ\201\230;\2074\264\216\300\020/S(GW0X9\307B\021\330\026\263\251N\034v\267\205\352\234\001\316\202i5\006\024P\001\250\014S|\r\262K\312\240-\016\033[ZV\3432\"\"6\342\324U\310T\204m\261K\r\314\003j\354/B\204\327\035\303\240)\n\034\300\241\206\214\352\020*\250\204%B\222\243N\212\253B\222\243L\201\036\360X\0209\201\234\222#! \341TX\203\260T\325\247w\000)\211\0214\260\020\007X\035V.N\3647!pC\362!\000\240;\374$\2236s\000\033\021\370\272~\022\t \221\363\202\242xC$TOz\034H\237TD$A\220I\000\222Ad\t\020\262-\202*\035\"\275\315\007\030\232\253\327\326{\366\005\022)O[wUunl\272\244\010\0216\034N\r\317\245\200\203\304\035\271\346b\365!\320""\252\234`\006\367\223{\324\301\311\200\\zDJR\314D\260*\013\345\304B\010\210\2177\030\206\013\336?*Eq\003\221D\354\240\2204\255U\022\027s\001\327T\022\001R\243\303\213\261\016!\246\236\371\344$\203\207\0174-\200\301\262-\264\333\300\r\251\356\214\035\033s\200i\225\033t\313\255UI\032\344\365\006U\346\371(\0162`\207\231P!TB \010A\324<\220\362I\344\240\336v\035\t\t\010\356;\342l\037~W\321|\310\336\260#\204\205\354\007\270\017\240\332\222\217\356\224\207\204\274P'\343\002R\203\341\000\345 @L\002:\026\225 \014\204Q\240\360IDG\322A\005\"*\036b\373B\364A\376B\364\005\366\321\350\201\357\001\320@\377\243\321\037\374\275\021=\320\350\257xz(oNh\373\3571l_\2019#\340\016@q\036\013\345\007\000\365\270\217\245\305=^O\257\3018\006\241\246yg\334QD\377\004\177\330\021\020 \037\251\370\027w\244X3\377\217\257O\335\331\246\325\022\222v\330\"\2339\"\324\333X\010ss(\222,\214\007\014\232\225\206\360\245v\230\232x\210i\272\221!\247)]C\030\245#x\262\206Hg\016\0141Ri\034\006\301\t\006\220\314\023Ul\3411Nqb\251\244i\\\251\301\201\3149\253\242\255\026\210\272\251\314\3126\254)\253\006j\316Q\267f`\252.\025\0041\003h)\"\354\242% s\004\254\222iJ\300\356\324\246U\221n\244\323\251\312\241\227+\025\032\243mM\331\314\nJ\262\346\246\177\370\273\222)\302\204\202\214\0363p";
    PyObject *data = __Pyx_DecompressString(cstring, 6754, 2);
    if (unlikely(!data)) __PYX_ERR(0, 1, __pyx_L1_error)
    const char* const bytes = __Pyx_PyBytes_AsString(data);
    #if !CYTHON_ASSUME_SAFE_MACROS
    if (likely(bytes)); else { Py_DECREF(data); __PYX_ERR(0, 1, __pyx_L1_error) }
    #endif
    #elif (CYTHON_COMPRESS_STRINGS) != 0 /* compression: zlib (7926 bytes) */
const char* const cstring = "x\332\255]Ks\034GrNF\310aY>\330\033^\307F(\354\210\221_\022i.eje{W\016\333\001\002\004\t\031\240Fh\022\262u\231h\314\024\200\226f\246\207\335= \301\323\036u\344QG\036q\304\021G\036u\334\243\216\373S\\5\335=]\235U\231\2255\240\"$a:\277\254\367#\253*\037\267\267\237\355l\r&Ev\256\212AV\016\346y58\311\227\363\311\340\223\235lR\377\314\364\257\361rg\205y\244\252#U\224Y>\037\224\027\263\343|:\310\346\203iv<^N\322{e~\357\376\223\274R\203\352,\255\006\333\027\325\231\206\351D'J#T\221Vjz1(\253\"\033W:7\r\232\017\206\017\207\277\376\374\267\237\017R\235G\241\276S\343\252\034\224\313\343\3614-KU\016\362\223\301\3612\233V:\223\352b\241\312{\203\275\223\301E\276\034\314\225\232\014\252|\260\3208\233\241:S\272d\2522\177\014>N\347\272\002i\245K;\322\354\331\374\364\343\301$+t&\272*\206{7\235\226\352\336\275\377N'\223\221F*O-\013U-\213\271\316L\025E^\014\306\371D\rLe?=\326\315\242S,?\035es]\235y:\375t4?\237M\357-.^\256Z\243\005\334[\003\356-\253lZ\236,\347cS\244\201Ao\347\263\305\262R{\363\262J\347c\265\243t\363\344\027\275\236\340\360\272\240{\363\223|t\376\031\315\262\243\316\263\261\332\236\252\264\330\032\2175Y\267\346\3510\233\224\"\226\355\305r\353D\017\201\254\272\020\341\037\216\307\017MKm\233\214dY\354fj:9J\247K\025\306\027J\217\242G\213e\333\000\321\014\337d\325\331p\232\216\325L\315\253\020\367NV\216s3\036\026\313`\321tWl\r\367\016U=\276\263z\344\207\030\326\375q`\306U\014C\242\307u\031\305!\351\362\036\303\203\345\311\211*\222\354\225\254dfR\035\235\n[j\222.\014~{\232\217\2777#\330TG\3109)TYF4Y1>\313\364\324\326\323X\004\257t\377\035\353)V\n&\225\301/\253\374A\236\227\225\232\254*S>\234\247\307S\275^\204Y\037l\035\336?P\263\274\2700- a\310\323b\2627\221\"\207iQ=Y\316\216\321\312Np\024f\t\226\340\262\311\251\332>\313\026\322B/\313\247z\351\026 \267?\033\233>5\351\036I\340\351\"=\316\246Y\225)\311\300\331\236~\177\220\317\305\343l=2\245\330\257NN\364\276#NZ\202\353\257\365\242\216ox\204s\243A\037.\347s\263@\024\371X\231]tt\376\033\021\363\374\244\315N\315\3142!m\256\216Q""gi\246\246\232\324\363\340Y\231\236\252\270\024\364\322\274\255\212*;\311\306z\241\217\346\325\323]\257\330+\021\341P-\362\242\022\245\220OU!\256\254^LeK\211\265\325\232]*\233'\343\\6q\344{\264A\233-\321\254Q\322\305z[K3M\213\255\347\234(\243eQ\014\307\231\332\317\346\337?Rs#\000\312\266E\233\361\233lR\235\ty\364\216\336\254\301\347\372\317C\225\226\371\274\214\344\335-\324s\t\317\2162\242`\361LKt\331+i\305v\324I\272\234VZF\022N\320\372\217\307zi\236\252\335\"\237\035d\247\366'I\nY\271\230\246\027\365\366,\307K\313W\244\263\207\363qq\261041\223\221\261\rx*\233\030;\027\363t\226\215\207f\242\252R8\361\344\215\254+`\272\322\214\355\261ld7\034\211\021DdC\254\345\020Jm\r<nt=\324\rS\214\325d\230\277P\305~6\313$\213\331\356\203\355\210j\030\264\260\n\273\351\\/\265\37243\035\346\323l|!\353j\315\225,\364\331\356px\020\201\216\200\n\213!?\222h\364\243\305\330H\027\331\374 }ytR\013\002b\266(\206\345nz\254\217\027R\021\311:\367\350\235\366$\233\252M8s=<\364v\261>5\t%c+\211C5K3#bD\3141\213\275\214\203?\270\020\211J\026G,\336jL\223\231\260A\365\350\330h;\324\254_-\032\270pI{\244\245\364}\375\347\2744\033\375\256\336\360\365\351G\367\333\347\022\336r\261\233\025\263\027i\241\332K\220(&a\021\353\035L7\337|\242^\312FT\313\242[Q\237*\366&q\\\211*\262t\032\301\360\354\331\336N$\\2\022\036\353\303\242\021\275\244\355\244\341z\373S\243\363\373\002\364\2525E8\275W\3443#\014g\247\313zlm\237)-;-gr\366\275\231\226\327\345\203\244\341\212`(\236?\021\225\347\313\305i\334^\271\237\226\325\203\007\377\273;]\226gO\263\231\244#\016\206\311\215\316K\007iq\232\315\237\252\331j.\313n#\364\222\021s\0205\360eY\3453U\254\356$\244'M\315\267\226,W\007\026\031\317F\253\231\305'\225\355\365\341p\223\375\265f\213c\320\207\320\210\243T\315\240\327\242\210\232h\206\356\202Tt5\323\335\021\311\026<tHh\226X\031\243pQ\252\373\242\271\367\030\032\221P\316\025!\264i\206\274\020_a\351\262/\247\262\275\374@\237\3022\275\257\256\356\311\004\370'\251h\211\320E\325\265+eHss\221\027J\210N\237\230\2531QY\317\315\334""\212:\251\327,\221\303\262f\022\256L5X\313\201y\245\364\364\227\017f\233\261\376(\274M\254\031\245C\263F\313w\246'\347S\215\177\360B8_jx\262\\\230+&5\251\371$=\377\325I\032\267\261\r?\033\212\3578\233\216x\370\262\222\203e{]\273\302\353\351.\235\353\206\345P\231\273\007\371\0204<1\351?=+\362\345\351\231\336\303%\014\223L\202R\205\026jf\346T \035k\026\213t\030\014\315\300,+\325\260H8\214\204\251\252t\222ViR\025Z\\\2210M\323\312\024M8\251W\027\r\007\351\\\013\201\346\\(\275r\360\261iA\264\254\n}H\024\335-\240\024\232k\265\270\374\263W\365\035\224L\256^\361$\371\262\030+1Z:\034\014Xz\363\335\310\234\221kB+\250Zl\302.6'\367\305BM\016\363\027\245\010\276H\263B\274\000\035\252*+\324d\250\353\036\013\227\355\0366\307P\255\336\343\345\205\313_4\265/\036\353\271\227\237\026\251\344(\322?\034\354\350)\230M\3675\277\2005Ig\213\251\250%\304g\331\304\\\3206O\362\342\232\033\246g\363\354\371R=\233\217\363\242X\275\320\304=\354\233T\332\335n\243;\3715\367\212\317\354\371Q\\\217\212tq\226\215\313:\357\030\316Z\332\216\347\303\033A\024\263\364)\346\251>CF]{Z\307\315\2438\270\336+Uy\226OE\271\234)]\363i\242*\2437 \252H\276\310\247\371\251\336\353g\263|\276e.\371\252\274\210`|\242R]\276J\250\231\3614\257\322i;\202\345\014\372Xk\2128/\227\263\205p\255\025^\032Y+\361\241p\260\034\035gy)\227P\315\220\212|\"7,\217\225\026\275\362S}\242\317\227\245P\3260|\353\273\332\370=\346\310\022U\204\360\215\266A\213q\323b&\3433e\016\231\305~~\032\313\"\225\007zL\033\364\240Y+\327o\274\335\245}\004w\267\246\305rGvHVT\313\264e\220\014\266\2752\362\005T'\232\235\\\354\030\311R\324\376_\315\365&\254D\327\002\265\2207\313s\363T\177\272z`M\215F\203*W\022\227y \210K\342\331b\202\023\030\246\002\241\243\237\212^\204E5\375z\251\212\210\206\321;\367\344\233\"\323\345;<\020\210\314\207\352\324\234W\212\325\356]\206\321\263\374\334\250c\010\244\272C\323<\032\272\2577\350V\266\020\361\324\033{4\233{7\022\344KbU\001\223XU\300ds\305\263$N_)\211\322)Jz\3725\317\346\013K\277G\242H\230D)\263$k\215\212\0334F\223B\304""\373p\262\211\336C\322\323{\020\240\205\372\013\211\373\322.c\211\250m\344lK\342\237,\223\250w\256d\223\311\234\210\357\267\223v\322\327?\367\363\027\253\025V,\020'q\327\203I\364\365N\262\331\325\013\301&\033\003\321\227&\311f\247\211$^rM6\224\\\223M\004\264d\023\261\345H\243\315\336\336<\200\206\340\337\344\305\367\323<\255\025y\032I`\245)\177\250\364\231\334,r\315G\246i\232\023?\177\361\267\332\235\223F%P\205q\273\205\022\240\276I\003\203\312\350*\275\034O\227\0235\021\2759:\370F\361\202\177\326j\317@z/\322\035\025z\013i\320\365\032-\033}\rK\360H\366ha\364\366\352\313\235G\334C\244\006\326RY=\322j)<\014\337;\321\375\254\322\231\356\352\340\266\247yd\005Y\211\221\362T\327\347\277z(!\325\345\3159\205\346\032V2A\023\032\013+\265[\350\263\240\"\3124\253\330$\"\364\243\370\2428\252Z\033&\264)\037\257z\205X\205z\310}.\376\260\336\307F\356\n.\263tk`8\331\213\002\227/\372\360n%\221\334\244\306\221\233\341\236\226\317\315\334\334\235\246\334}\237\201\261[A\"\\C\223\263e5\311_p\210\013\2751\316\244;Z\037\315\357k}\254\331\335B\330\276\231\201l7\361q\006:\301\307b.D\315Y\375b\003\336\377Q\027\207\215\275\344Z^\343\347\233\267\320\301[\340\216k9I\353\0357<\000H\036~|\265l5\213\261r\032\237\211\341\362R=\316\306r\360\223\243\203\375\010\264\350,\261\20677\234\274\306\312\032\335^\247\353a\223\250\340\270\226\336\352\324\350\344\006\0033y'\003S|\022{\246\327\251\326X'\210\252\305\2632\210k\017\331|I\033\260PW\253A\357\253I\240\031\033\340\260\\\212\262\027\251%6X\363\277p\242\211\244\224\366\313A\224\205\262\315\030aHK\262m\230[\300\030\002\361\005\257t0^j\230\342\347\213,\234\324\246\005\361\205MB<\014\321\231\034\007\024$0\276\320\313\237yX\013\\\214 6\241I\200\313e\224\243\344\014\265f\276\n\275\307\373\271\202\252s\210\355`\242\316\371GI\314\020|\212C\014k15\242\t\016\315\374\231\325\002\016\1771\214\030y\355?\004\216\252\367\321L\270\351;|\322L\222\310)m\352\332\330\211\363\353\255\005\226\t\2336\203\361\234!B6w/;\"\360\356\261y=)\316\003o\2016G\304\234\265Y\216\005n\n,""\036\217\031\317D\306X.\036\253t!\316\250\231\257\"\354A\372Rp\364&\030\206z\314\3166\341\022\371\321\260\330y\231\322\006.g\215\035\251n\261\211\254Fz\270\344\323\2453Zv\033\370\223\274\3325\277W\367\232\346\336_\177\350t\204\314\307\321hx\361R\377\273\223\215\253\321\023\365R\247x\222\226\027\363q\226\337\033\347E\256\323\236\253r\254\305A5\312\346\243\252\320\253\326q:\376\236r\326\262\362\346\262\".\322\352\314x\301Q:\017e\310#\375\217z\251\217\266\372\037S\037\375\277l^.\224\316\270\255\336h\221\257R\"\t\345(+G\353reZZ-\315\235\257\3165\233d\351hR\333\274\216\246\331\361hdn\207L^\263\225\206\373h\264z'i\376;\032\321~d\274\264\316gLM&\375\3038d\353i\316\241\365\325\303\034\262eP\331\243\261\356YX\244M\264\375\264\330\337\035\237,\230\350\361uBBV\357\036#\306\271\nI\\\311G\016u}\357\210)~\337(\016\312\366\203\202\211\226\317\023L\262\375\233`\032\361\212\212`}\277%\230X\373(\361}\355\374\221`\252\361=\342|\263\375\214`b\355S\004}\265\375\207`\222\265+b\222\345\027\304!5=\340\373\336\274\237\373H\370\033\366\343\341\247{\372\221\2667s\200\254S\013\026m\271\317\240q\226\207\017\032\344\363\346\341\240[\337\031\016\241\366\223\201?{}b\320 L\351\3351c\242\317\257\205\203\361\371\260`@+K0\017\275\347_\202\241\367\364d\021\316\3659\341\000l\377\022\016\221\365%\201\321\266\337\010?\315\227\207\243\027\341\000l\337\017\230\350\370y@\000\177\305\220L\355\247\266GN\202\352Y\241]\037\014\016\000\373[@\000\353\244\353\241x\262\364\370Lp\021\255\177\004\202B}v\223\362o\311\204?\003/\204$\332~\n\\\242\375ZDS9\232\327'\001\003\267\236\350D\250\225U?\215t\336\353h\250\333\266~?\000.\254\247@\203\311\224}?\306\365\315\362ij{\227>bm\364\t\262e\217O j{\005\202\2702\234gh\230d\331\317{H\215\016\021\242\3245\030\211m\340\375P\333\336\335\217 \210+;v\364\261o\263\216\210\330>\035\221Y[t\214\305v\347\016\375%%\350x\355\311]L\337v\334\245\007G;\266\t\307d\217\375\267\027B\023-\273n/\261\265\341\366\022m\345O/\300s\236\"\355\260]\220g {\354\253\275\010b\321\267\354\2461\245\261\221\306""\237m{hD{\222:\303\257\261sv\277\2666\315.\245\261_\306\004d\253\354%3\315\337\331 {\t\330l\230\001uF\311^\220\257\013z6\303\016\255{v\362\222\260-0\002\365\355~\021qm\343\213\277\257\355y\375\004wm\300v\272\036r\317&\327C\247\370:[[L\234d\370\0132\210\245\311\276n@\312\223\230\352\330\301b\200e\363\212I\264\231)\217\224B,\253W/\332R\267\364\321k{T/\305\327Nk;SLp\214i\374\000\307h\006\301l[Q\207\324\331\205:$\302D\223\301q$g\002\373\35481\204\260\331D\260\306>\023\177\365\3116\256\335\245\007\020\260\261\304\034\264=%\205\354l')D\337N\222B\3316\221\024\306\261\177\244\200\276\243x\337\256\021\023=j\3044\004K\222\3106\021S\275v\210\004\310\2629t\020\266}\241\227\210m\t\021\310#\350b\033AD\266\355\0011\tiP{\310\216\226\230\007C\331\364y\240\355\022\353!\005\227\027\316.\317\003\365\332\306q\270\375\374\224#\373\326JF\025\217@zl\346<H\246\021\034\245r\033\340\330\275\331Dl\343f\323,{6\373\263\300v\215\206\267\026f4\202\262d\2639\220\375\231MB\266f}\222\255\201\324\247t6d\375\357\256\275\230Cw\315I\034\210\307\016\314\306$\334SC\302\275#$\262\213\367\204\276wN\310;\344\220=\026\306\372/R\303vV~4q\367\224\204\356\t\373\266R\210\342\271\003\364\330@\271d\242$\314\310H\370k\230\204\274oHB\003*\361\236\373BvG\016\326\177\304HX\2218\t\013\253\264\235\220\027E\010\251Ix\343N\370\235*\021\354TIh1OBK+\262\315\261Ir;\234\232\313\262\271i>\364\264\221\373\337\214\316q\377Kc7S\177\364\333\310\0204\313\036f\215pl_z\024\327\316\245G\356\211\025\310~e\375\321\265U\351\223\\\273\2245\335M\314co\322\322x\013\021\031\312\363\256\354\332\2148\337}\357\264b[\020\001\234\270G\216\264\361\0200I0\335m<g\247\341Ct\202\232\300\376\202\002\372\2460oWAaX\301M`/A\001}%\354\331At\237\326\3238\361\314\247\326\226\241\371\345\261[\360Q\272\365\302\265G\260\277\323\266\0074\252\257\233M\343(=l\232\243\177\354\"m\0340\331\321\361\037\005m\000\020\304\326\367\367\222\374)wz\374\210`\351\354c\212\263\017\373t\361\021\245\257wo\023}\022nX\237\236\306I\372\314+M\330:\361\275/\215\376{\357\233\255\353\336#""x\356\276\221\016{\357c\243\257\336\373\346<] =\364\356c\202S\r\350\227\273 B\343\207\325\033\017@\254\207^\277>\270\237\346{\324\346U\266Y\014Y\010\347\221\232\320\357\366\023\217\255\013EV\007\333\013\361\274\366\022\272\325^b_#\232\203\330Wp\204~\264\237\330\273\326\240\365\236\275t\254\343\354\005u\317\022\036\335e/\001\351)\023\030\037s\302\014+\244k\354\020\334\215\004\353\020;_[}a\207\320\323\rv\251\304\270\361\353\374:t\237~\257\013\352ty\035Z3d\234\357\216\312m\010\341(+\022P\207\330\355\027\264N\255C\357\364g\027\371b4Z\\\274\034\215\323Ef\024D\237\353\323O\253,j^G\353\277\365_\223\372\234>\032\031}1\375_\275?\244\346\002~\025\247\360|\245\0322>KM\324C]\326\301\235OL\226\207\253\200\210\243\3526\330\277\006\237\254\200w\356\016\226\3632;5\001\023\263\271\306\370@Mjw-\217\007\232vG\203\021Z\247\260\372\334\377\352QiuK\343\005\335\365\205P\\\215\366U>\276\024\272\355VU\344N\032\346Nn\306\275\332\244\365\014,\305\340z\017$\320m\233\233\026\007`\000w\007u\257\336\026`\372=\277\t\217\2408\364\210@\230\016\032\302\326\203\242S\206\032\205s0\277:%\330Q\260\262+\274\321q]-\366Bx\253\376\3728\323\262O1>\223\346\323\250\306\212\300\226\306\254\271\275\221\361\330\372\262B\216\365\265\245\260qW\034u5\254\017z\035\257\342F\2317\255F\275\320M\353\206icfA5\255K[Y~6\203\004\316k\005\013\363\244\224\205c\331m\035b!\357ZYX\204\257\177!\315\370\030N[m>\206\257\323\251\217\340\352IT1|\2166q\004\263y\245\255u,b\230z\367\274\345z\251\020\262\367\356x/ZZ}\311\327\354S\2677N*v\312\332\362\206\024{76\361\273\255w\215\341gC\263m\327\207\337\336\347\230\005\324I\266\275=\330W\347j*L\243\367\342\322\316)\216\266a\232\215t'\341\356\236x\254\242\364>F\246\202\345\211\020\263>\2007oy\365\".\342X\251vXz\035\242b6|\256\306\207\245\356!K\310\2366\3656#\330i\020\027\225TT2\267\2433\216\356\236\372\260Jm\260!\366\365\315\205\014m\337`\2118\326\357\030\222\201c\300\315#\2110\361\245\307\034B\312j\253\337Ky\372\017\235\353Q\342\243l\222\236\210\007-l\256\204\026\273\204\3534=\317\1777a\0250""\372\225\363E\231\366\224\333\305\034\355\033\264l\0267/\235_\035\177g\354R\311\303X(\031W\257\\T^K\245\332\226\312\361Rl\203\367\363q}Ud\017\210\341\377\215\366\277z\362h\365\237w\232\357\rs\210i\005sk)\202[z\316\021\370N}@\3125]i\351W\3153@\004S\262\021\023\326\201\026\361\016\017\017\236\356\037\211\317\253F+\264V\0205W\265\333\351\262T\354\321/\266\327o\226\376M2\356\264\275\253\010\274\030\254\214\262Z\253\367\275\301\366k\364\274e@[\003[\306\321\3236k\025\326d\253\037\322e\253\304'Y[\345Z\316P\337)I\347\271\253\201\034\303fi\027\266\202\211{\253A\2148q&\256\212\246\254\210\355\255\213\254\223:t\354\266\324S5\027\025\255U\332S\223\255\341\036)g\337<\025A\032\036U\365\306BST\206U\257\353Q\315ne5t\225l{S\350\227\263\2721\024\316\331\247\352UF\234\234I\376\330U'Z\036\261UrE\014~\235\221\033\261\212\317\314\254V\2668\005\333&f\264\321\305'\253\262-N\301\257\311\035\317\376\250UH\216g5jD\361\\It\206f\246\325\367\327\353\346k_\217\273e>2\245\330N\363\2513\272\232\214\301\244H\201%p\035\020\226\200\246\371\374t\243\3347`\271\333sY\036Z\234o\266\220\332\263\326\273Go\2249\225\023'\014\0103Z\277`p\377\310S\352\335\3464\312&\262\225\302\227N\247\260\262y\032M\033u\tD\247`\367\351fe\260'st\021\310\256\332<\221\270\005%.\255\315\323\276\035S\251\272a\261\352UT~qWL.g\224\334\350\262;v\014\357$\215\330\024\3047\233>\326N\375f\255o}\243\021\300\246\333\323%y\264\351\224t\263\350\364\270\327g\267\315S{\027\374\357\240\375\260%\344\006\251\354\315{&*2M\0037\031\307\354\277\272i\365<\236\0026\275\312s\023\027\337\234\270\254kd\024\247gu\337\224\371&\r\213\327\341\r8\243D:\037k\263\2447Vi\265\367\257\312;\231:Y\316\237!/\353uTK2\334\361\036\220|\354\275\331\032\004\264\373TkZ\"\321E\363$\360hc\316\325;\272c\"\261A\"\342\203p\004?s\032&R\261\217s\033T\242o\330q\343\004\"\231k\0310\"Ww\225\301&B\261\033\357M2\350\355\300\216\312\345\273\311\217\334@7I\350\306\r\362\016\331\375\255\353\021>\334<\002\233\222EnE\332*\035\237\031{\223\3661\276\275\347\357\374\333T\242\224\004\".\317""\343\343ht\\=\226CD\0265\203m\346\323\345\030Z\255}6W\315M\010\237\235m\214\025\305`\254\264D\014=\363\237\000\307\312D\240\242\365\251=\034\3066\255\351\372}5\331\316\247y\341\357\017\204d{\333\306\016\223g\334\260\264\241\346\357V\353\242\2242H\022\217W\032\360qJ&\272\307\224V(\314\366\357\017\302\210\0305k\t\247_\236\223pv;\327\321l\217Ui\306\251I\225\216||!e\036\037\217\371f\333\010E\262\306^\221S\351\330vB\221\254\266\tQ,\257}\267\024\346\2128*\221\254\334i\205g\212\275!\224\244&\273'\014\245\024\337\3557\277\t\343R\214\305G]\211\271\243\236~2\262)}?\003L\342\335\343\005\265\232m\304\030\316n}\350\331`\231vS1_\036\244\305\375\320\300\362\274\325\270\217&\033\262FOY\372\341(\246\020\033^1\264\251Yvo\\\303\265\266\2152\210\265#\321|\276\033s\016\321h\327\2758\036?\234W~\265.~?\3557\231d\330\306\334C{n\236\035\227 2\276Z\366\t!\343d\252\363<\233\350\026\301^Q\2001\304\007\322\336\036\202^\207\201\363:\014\264ga\010\270\025\200\260\333\001`\302o\000\037~\003\242\375,@\264\225?\210<C\000\357\235\001\3708!\300\304\t\201\200'.\010{\342\002\322G\025\320n| \344\351\032BnB\201\215`\001A\377\320\340z\321\005\237\343Hp\375\000\002\355\350\01787\354\300\371D\006A\360\003\010\373\201\207\260kf`\202\277\000\351\203\036\270 #\340\t\030\002\\\300\020\360\006\014\001:`\010\320QA\200\216\376\001\264\2036\037\027\004\275<\003\021\201\004h\237\335 \360\331\rd\304\021 \375\310AT\210\021\020\206\030\001I\210\021\240\202\206\000\027\004\007\350 8\300\004\301\001:T\014\004\342x\000\357\307\030\002>}!\340N\rx_i\300;\375\204\250\360\037\340w\032\t\204\347i\220\270Q\205Pp\020\010y\005\004.z\010\220.\003\201\217N\005!_\275\020\355\253\027\270\250Q\300Ei\001&\356\n\220qW\200\365\201\rB\027\313 \213\377\004\336(,\3009\270\004\231\203K\360\372v\004\326\233!Dy\246\0046V\014\370\303\262\000\031t\005\034\017v@\273\303\203Px\033\340\342\246\000\037\021\004xO\225\020ta\014!\007\264\020r\243\010\302\240$@\007\360\0002\200\007\220\2566\201\213\274\001\201\340\027\020\n\360\000\234gg\210\212}\005L""\254\010\240\002\031@\204GP\240\203\016\000\355,\024$\361\010\200\366\307\313\254.\300:f\007*\\\001P\341\n\200\213+\000N\\\001\240]\373C\234\367c\210\366m\014A\177\311@\272\360\007\221\367U\2209\255\207\220w\177\220y\367\007>\n\003Pa\007@\352 \036\350\030\001\300\005q\004\316\3552\204\235\377\203\327\253?\204}\327B\330/=\r\301\3539\366\356\016\002\037\355 \360\216\013r?\356@\373q\007\271\213v\020\272h\207\220\017v\340}\270C\310\355/\210}\270\203\330\207;p\216\273`#_\301 \014\376\007\342\360\017\020\014\377\000\222\210\004\300\207\240\202\010\277\342@\272l\007\326)>H\302\007@8\210+\210B\252\2027t)\004\242w\202$B$\004\"DB(\224 !\202\002\023.\017d\221\346\300\023\031\r\344\221\321\300\027\332\014\0021\301@\020\023\014\370\230`\300\205\355\0022\376\025\370\343_\001\023\377\n\274\301\256\200\014v\005T\260+\340\203-A \330\022\020\301\226@\034\245\010\302!\210\200\n\022\004\\\370\t\0108\372\0066\006'\220a2A\032\377\026\"\342\341\001\031y\031\270h\261\300\305\257\001.\0204\204\302\266B(\322(\260a\034\201\013$\010\336\370r\300E\217\003.\366\030D\205\261\002A\004!\240C\260\002\035Q\n\004\0019 \024\206B h\003\343\221\036\330\010\337 \t\377\007dt9\010\306\202\005>\346\005\370\274\365C\\\014U\020\007g\007q\034U\021\362\210\315\031\330\030\2624\325\021|\372&\020 \t\032\010|\310B\010\205,\004I\320A\360F\007\0012\226/\310c\323\002\023\265\020\2700\\ \212\031\006d\244\025`#\255@(`\n\220A\276A\022#\034\270\030\240\340\t\317\001Nx\016\360\205\347\000\"x\004\360\301#\200\210\233\000qA\014@\032f\001\244\321\016@\020i\001D1\033@\0247\001\202!&`\223 \030\020\037\006D\306\002\262\310\031\002\230\244b\304\354\025\007\035\261G\375NV\216\363\363\225\037j\264{v\221\262\200\216\310\005L\2101\010\006|\000:\034\003\220q/\200\210{\001D\334\013 \343&0J\037M\033\241x\001\340\013M\000\236\320\004@\205=\000_l\002\360\004N\000\"\270\001\360\001z@\022\321\0008'\372\300\371\277\007\312\t=\010\234\320\003\345\204\036\302\021\026\200\t\215\000\\D\002\010\307\004\000\316\251?\004\234\372\203\304\251?PN\375""\201\211\227\000\202\210\017\020\216\251\000\301\230\n\020\214\211\000\202\300\022\020\210\033\001\341\030\031\020\212M\001\202h\005 \010\264\001d\374+\360F-\000\237\363} b\002\000\027\025\001\250X\n\300\306?\200@\200\003`b\027\000\025r\001\370\240\n \t\232\000\301\000\010\020\210Q\000t\214\002\220\307N\000O %\360\004+s\356\016L\334\232\265\274\346\r\247\006\302\210H@G\374\001'V\016P\021\205\300\215\030\005\302\360>@\007\353\0012\344\020\261\007\326\316\210\311\206\261b\311\001\031\310\007\270hF`\207\301\202^\310\253\337\337\372\371\275?\371\371\275?\375\375\253\327\177\365z\353\347\367\177\371\207_\336\273L\177~\357\317\177\370\335\353\255\327_[\344_\375x\353\347\367\377\342\207\347\177|\357W\257\237\377\374\336_\277\376\372\217\206\364\376\017\267\376\360g\177\363\343\227o\322\356\347\337\275\271s\271\325\375\374\333\037\277}\363\274\3739x\363\301\345G\335\317\177\276\374\342\312J\352\366\345\207W\367\273\237\237^\276\272\376E\367\363\263\253;\327[$\370\223\313\017\256\254\224\357^~ye\225\352\316\345\235+\213\367\2437\037^\336'\223\372\2077_^\246\344\317\277\177\363\305\245U\346\217\337\274\272\372\005Y\014\004\376\2477\337]\335\"\253\177\357\362\273\353[\322* \336\373W\037^\337'{\001\025\003\375D\025D\205D\371\242R}~\365\345uJ\266$\372\211\312\214\332\n%\205j\204\332\031U\020e\364\353\313o\257\236\223eF)\177q}\347\355\026Y_\324)|\215P\276\250\202\350\347o\256\276\270\266x\377\355\352\273\267\267\310|Q\343\240\251\201*\210\250\250\351\370\016Ec\003\025\022\375\374\327\253o\257\237\223U@\003\211\037\033\250\030|\227\375\343\233o/\351vF\025D\353\006j\034\324e\250\331\377\375\352\325[\013\374\273\353\017\337\322k\316\277\\}p\375\221\264\n\277\275\376\340\355Gd!\321OT#~\210\362\313\346\177^\177\373\366\271\264Fh\324\241\n\242|\371\305\034\215\034\224\024\372\211\372\027\265$\242\242|\021\230/3\242\242\301\200\332\031Q\371\356F?\371\271\300/\365\210\212F\316\177\\\177\361\366k\351\034\344[\022Q\321\276\0205\177Q;\243%\010\255\033|1\020\230_\030\321\204E\243\235\247n""\275\375\360\247\373d\303\"^\004F\263\233\037W\374\310\3417/~e@\274\250\314\374\302\310/2\250\314h\230!0\0329\250Th\344\240\336\3477\\\224\024Z\353P!Q\005Q\231Q\357\363\013\005\277>\363\222[\324LA\243\235\2277\370\271\200j\204V`\004F\243\235\037\014\210\227\007#\211\002\325\010M\0344rxA\035\255*<\0255\035*$\002\363)\243\244P;\363\023\207\027\250\320xF\2733\372\311\013\237\250\217x\301\006Q\371\361\314o\"\250\007Q1\220\200\201\352\213~\362}\304\027\022\215+\224/\177x\344\005u\376\344\205x\321B\201x\371\301\300\217\034^\346G\245\342{0\352|\304\257W\350'*\363\177]\177\367\323-R\222A?y\241\010\365`\224\230\207\006?\242\362\207e4\313P\343\240\321\216\250\374&\302\257\317\374@\342\317G\350'\352#\324)\250\314\250\027\320\022\304\037-Q[!0\312w\373\355\027?Y5\332y\373\345O\264\020\370\340\355\235\237\304\323\212?Y\243\n\242\244\370\005\n\365\021\222(\320\346\205\026F\324V(e~\267z\370\366\333\237\350\036\344ES~Z\361\365\345\267c~QE\031\241\201\324\224\371/_\3372\367\217\367\377\037\324\034l\200";
    PyObject *data = __Pyx_DecompressString(cstring, 7926, 1);
    if (unlikely(!data)) __PYX_ERR(0, 1, __pyx_L1_error)
    const char* const bytes = __Pyx_PyBytes_AsString(data);
    #if !CYTHON_ASSUME_SAFE_MACROS
    if (likely(bytes)); else { Py_DECREF(data); __PYX_ERR(0, 1, __pyx_L1_error) }
    #endif
    #else /* compression: none (59658 bytes) */
const char* const bytes = ")CUDA driver is not found (Did not find cuDriverGetVersion symbol in libcuda.so.1Note that Cython is deliberately stricter than PEP-484 and rejects subclasses of builtin types. If you need to pass subclasses then set the 'annotation_typing' directive to False..?add_notecuDriverGetVersion returned error code cuda/bindings/_internal/_nvml.pyxcuda.bindings._internal.utilsfunction nvmlComputeInstanceDestroy is not foundfunction nvmlComputeInstanceGetInfo_v2 is not foundfunction nvmlDeviceClearAccountingPids is not foundfunction nvmlDeviceClearCpuAffinity is not foundfunction nvmlDeviceClearEccErrorCounts is not foundfunction nvmlDeviceClearFieldValues is not foundfunction nvmlDeviceCreateGpuInstance is not foundfunction nvmlDeviceCreateGpuInstanceWithPlacement is not foundfunction nvmlDeviceDiscoverGpus is not foundfunction nvmlDeviceGetAPIRestriction is not foundfunction nvmlDeviceGetAccountingMode is not foundfunction nvmlDeviceGetAccountingStats is not foundfunction nvmlDeviceGetAccountingPids is not foundfunction nvmlDeviceGetAccountingBufferSize is not foundfunction nvmlDeviceGetActiveVgpus is not foundfunction nvmlDeviceGetAdaptiveClockInfoStatus is not foundfunction nvmlDeviceGetAddressingMode is not foundfunction nvmlDeviceGetArchitecture is not foundfunction nvmlDeviceGetAttributes_v2 is not foundfunction nvmlDeviceGetAutoBoostedClocksEnabled is not foundfunction nvmlDeviceGetBAR1MemoryInfo is not foundfunction nvmlDeviceGetBoardId is not foundfunction nvmlDeviceGetBoardPartNumber is not foundfunction nvmlDeviceGetBrand is not foundfunction nvmlDeviceGetBridgeChipInfo is not foundfunction nvmlDeviceGetBusType is not foundfunction nvmlDeviceGetC2cModeInfoV is not foundfunction nvmlDeviceGetCapabilities is not foundfunction nvmlDeviceGetClkMonStatus is not foundfunction nvmlDeviceGetClockInfo is not foundfunction nvmlDeviceGetClockOffsets is not foundfunction nvmlDeviceGetClock is not foundfunction nvmlDeviceGetComputeInstanceId is not foundfunction nvmlDeviceGet""ComputeMode is not foundfunction nvmlDeviceGetComputeRunningProcesses_v3 is not foundfunction nvmlDeviceGetConfComputeMemSizeInfo is not foundfunction nvmlDeviceGetConfComputeProtectedMemoryUsage is not foundfunction nvmlDeviceGetConfComputeGpuCertificate is not foundfunction nvmlDeviceGetConfComputeGpuAttestationReport is not foundfunction nvmlDeviceGetCoolerInfo is not foundfunction nvmlDeviceGetCount_v2 is not foundfunction nvmlDeviceGetCpuAffinityWithinScope is not foundfunction nvmlDeviceGetCpuAffinity is not foundfunction nvmlDeviceGetCreatableVgpus is not foundfunction nvmlDeviceGetCudaComputeCapability is not foundfunction nvmlDeviceGetCurrPcieLinkGeneration is not foundfunction nvmlDeviceGetCurrPcieLinkWidth is not foundfunction nvmlDeviceGetCurrentClocksEventReasons is not foundfunction nvmlDeviceGetCurrentClockFreqs is not foundfunction nvmlDeviceGetDecoderUtilization is not foundfunction nvmlDeviceGetDefaultEccMode is not foundfunction nvmlDeviceGetDeviceHandleFromMigDeviceHandle is not foundfunction nvmlDeviceGetDisplayActive is not foundfunction nvmlDeviceGetDisplayMode is not foundfunction nvmlDeviceGetDramEncryptionMode is not foundfunction nvmlDeviceGetDriverModel_v2 is not foundfunction nvmlDeviceGetDynamicPstatesInfo is not foundfunction nvmlDeviceGetEccMode is not foundfunction nvmlDeviceGetEncoderCapacity is not foundfunction nvmlDeviceGetEncoderSessions is not foundfunction nvmlDeviceGetEncoderStats is not foundfunction nvmlDeviceGetEncoderUtilization is not foundfunction nvmlDeviceGetEnforcedPowerLimit is not foundfunction nvmlDeviceGetFBCSessions is not foundfunction nvmlDeviceGetFBCStats is not foundfunction nvmlDeviceGetFanControlPolicy_v2 is not foundfunction nvmlDeviceGetFanSpeedRPM is not foundfunction nvmlDeviceGetFanSpeed is not foundfunction nvmlDeviceGetFanSpeed_v2 is not foundfunction nvmlDeviceGetFieldValues is not foundfunction nvmlDeviceGetGpcClkMinMaxVfOffset is not foundfunction nvmlDeviceGetGpcClkVfOffset is not foundfunction ""nvmlDeviceGetGpuFabricInfoV is not foundfunction nvmlDeviceGetGpuInstanceProfileInfoV is not foundfunction nvmlDeviceGetGpuInstancePossiblePlacements_v2 is not foundfunction nvmlDeviceGetGpuInstanceRemainingCapacity is not foundfunction nvmlDeviceGetGpuInstances is not foundfunction nvmlDeviceGetGpuInstanceById is not foundfunction nvmlDeviceGetGpuInstanceId is not foundfunction nvmlDeviceGetGpuInstanceProfileInfoByIdV is not foundfunction nvmlDeviceGetGpuMaxPcieLinkGeneration is not foundfunction nvmlDeviceGetGpuOperationMode is not foundfunction nvmlDeviceGetGridLicensableFeatures_v4 is not foundfunction nvmlDeviceGetGspFirmwareVersion is not foundfunction nvmlDeviceGetGspFirmwareMode is not foundfunction nvmlDeviceGetHandleByIndex_v2 is not foundfunction nvmlDeviceGetHandleByPciBusId_v2 is not foundfunction nvmlDeviceGetHandleBySerial is not foundfunction nvmlDeviceGetHandleByUUID is not foundfunction nvmlDeviceGetHandleByUUIDV is not foundfunction nvmlDeviceGetHostVgpuMode is not foundfunction nvmlDeviceGetHostname_v1 is not foundfunction nvmlDeviceGetIndex is not foundfunction nvmlDeviceGetInforomConfigurationChecksum is not foundfunction nvmlDeviceGetInforomImageVersion is not foundfunction nvmlDeviceGetInforomVersion is not foundfunction nvmlDeviceGetIrqNum is not foundfunction nvmlDeviceGetJpgUtilization is not foundfunction nvmlDeviceGetLastBBXFlushTime is not foundfunction nvmlDeviceGetMPSComputeRunningProcesses_v3 is not foundfunction nvmlDeviceGetMarginTemperature is not foundfunction nvmlDeviceGetMaxClockInfo is not foundfunction nvmlDeviceGetMaxCustomerBoostClock is not foundfunction nvmlDeviceGetMaxMigDeviceCount is not foundfunction nvmlDeviceGetMaxPcieLinkGeneration is not foundfunction nvmlDeviceGetMaxPcieLinkWidth is not foundfunction nvmlDeviceGetMemClkMinMaxVfOffset is not foundfunction nvmlDeviceGetMemClkVfOffset is not foundfunction nvmlDeviceGetMemoryAffinity is not foundfunction nvmlDeviceGetMemoryBusWidth is not foundfunction nvmlDeviceGetM""emoryErrorCounter is not foundfunction nvmlDeviceGetMemoryInfo_v2 is not foundfunction nvmlDeviceGetMigDeviceHandleByIndex is not foundfunction nvmlDeviceGetMigMode is not foundfunction nvmlDeviceGetMinMaxClockOfPState is not foundfunction nvmlDeviceGetMinMaxFanSpeed is not foundfunction nvmlDeviceGetMinorNumber is not foundfunction nvmlDeviceGetModuleId is not foundfunction nvmlDeviceGetMultiGpuBoard is not foundfunction nvmlDeviceGetName is not foundfunction nvmlDeviceGetNumFans is not foundfunction nvmlDeviceGetNumGpuCores is not foundfunction nvmlDeviceGetNumaNodeId is not foundfunction nvmlDeviceGetNvLinkCapability is not foundfunction nvmlDeviceGetNvLinkErrorCounter is not foundfunction nvmlDeviceGetNvLinkInfo is not foundfunction nvmlDeviceGetNvLinkRemotePciInfo_v2 is not foundfunction nvmlDeviceGetNvLinkRemoteDeviceType is not foundfunction nvmlDeviceGetNvLinkState is not foundfunction nvmlDeviceGetNvLinkVersion is not foundfunction nvmlDeviceGetNvlinkBwMode is not foundfunction nvmlDeviceGetNvlinkSupportedBwModes is not foundfunction nvmlDeviceGetOfaUtilization is not foundfunction nvmlDeviceGetP2PStatus is not foundfunction nvmlDeviceGetPciInfoExt is not foundfunction nvmlDeviceGetPciInfo_v3 is not foundfunction nvmlDeviceGetPcieLinkMaxSpeed is not foundfunction nvmlDeviceGetPcieReplayCounter is not foundfunction nvmlDeviceGetPcieSpeed is not foundfunction nvmlDeviceGetPcieThroughput is not foundfunction nvmlDeviceGetPdi is not foundfunction nvmlDeviceGetPerformanceState is not foundfunction nvmlDeviceGetPerformanceModes is not foundfunction nvmlDeviceGetPersistenceMode is not foundfunction nvmlDeviceGetPgpuMetadataString is not foundfunction nvmlDeviceGetPlatformInfo is not foundfunction nvmlDeviceGetPowerManagementLimit is not foundfunction nvmlDeviceGetPowerManagementLimitConstraints is not foundfunction nvmlDeviceGetPowerManagementDefaultLimit is not foundfunction nvmlDeviceGetPowerMizerMode_v1 is not foundfunction nvmlDeviceGetPowerSource is not found""function nvmlDeviceGetPowerState is not foundfunction nvmlDeviceGetPowerUsage is not foundfunction nvmlDeviceGetProcessUtilization is not foundfunction nvmlDeviceGetProcessesUtilizationInfo is not foundfunction nvmlDeviceGetRemappedRows is not foundfunction nvmlDeviceGetRepairStatus is not foundfunction nvmlDeviceGetRetiredPages is not foundfunction nvmlDeviceGetRetiredPages_v2 is not foundfunction nvmlDeviceGetRetiredPagesPendingStatus is not foundfunction nvmlDeviceGetRowRemapperHistogram is not foundfunction nvmlDeviceGetRunningProcessDetailList is not foundfunction nvmlDeviceGetSamples is not foundfunction nvmlDeviceGetSerial is not foundfunction nvmlDeviceGetSramEccErrorStatus is not foundfunction nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts is not foundfunction nvmlDeviceGetSupportedClocksEventReasons is not foundfunction nvmlDeviceGetSupportedEventTypes is not foundfunction nvmlDeviceGetSupportedGraphicsClocks is not foundfunction nvmlDeviceGetSupportedMemoryClocks is not foundfunction nvmlDeviceGetSupportedPerformanceStates is not foundfunction nvmlDeviceGetSupportedVgpus is not foundfunction nvmlDeviceGetTargetFanSpeed is not foundfunction nvmlDeviceGetTemperatureV is not foundfunction nvmlDeviceGetTemperatureThreshold is not foundfunction nvmlDeviceGetThermalSettings is not foundfunction nvmlDeviceGetTopologyCommonAncestor is not foundfunction nvmlDeviceGetTopologyNearestGpus is not foundfunction nvmlDeviceGetTotalEccErrors is not foundfunction nvmlDeviceGetTotalEnergyConsumption is not foundfunction nvmlDeviceGetUUID is not foundfunction nvmlDeviceGetUtilizationRates is not foundfunction nvmlDeviceGetVbiosVersion is not foundfunction nvmlDeviceGetVgpuCapabilities is not foundfunction nvmlDeviceGetVgpuHeterogeneousMode is not foundfunction nvmlDeviceGetVgpuInstancesUtilizationInfo is not foundfunction nvmlDeviceGetVgpuMetadata is not foundfunction nvmlDeviceGetVgpuProcessUtilization is not foundfunction nvmlDeviceGetVgpuProcessesUtilizationInfo is not ""foundfunction nvmlDeviceGetVgpuSchedulerLog is not foundfunction nvmlDeviceGetVgpuSchedulerState is not foundfunction nvmlDeviceGetVgpuSchedulerCapabilities is not foundfunction nvmlDeviceGetVgpuTypeCreatablePlacements is not foundfunction nvmlDeviceGetVgpuTypeSupportedPlacements is not foundfunction nvmlDeviceGetVgpuUtilization is not foundfunction nvmlDeviceGetVirtualizationMode is not foundfunction nvmlDeviceIsMigDeviceHandle is not foundfunction nvmlDeviceModifyDrainState is not foundfunction nvmlDeviceOnSameBoard is not foundfunction nvmlDevicePowerSmoothingActivatePresetProfile is not foundfunction nvmlDevicePowerSmoothingUpdatePresetProfileParam is not foundfunction nvmlDevicePowerSmoothingSetState is not foundfunction nvmlDeviceQueryDrainState is not foundfunction nvmlDeviceReadWritePRM_v1 is not foundfunction nvmlDeviceRegisterEvents is not foundfunction nvmlDeviceRemoveGpu_v2 is not foundfunction nvmlDeviceResetGpuLockedClocks is not foundfunction nvmlDeviceResetMemoryLockedClocks is not foundfunction nvmlDeviceResetNvLinkErrorCounters is not foundfunction nvmlDeviceSetAPIRestriction is not foundfunction nvmlDeviceSetAccountingMode is not foundfunction nvmlDeviceSetAutoBoostedClocksEnabled is not foundfunction nvmlDeviceSetClockOffsets is not foundfunction nvmlDeviceSetComputeMode is not foundfunction nvmlDeviceSetConfComputeUnprotectedMemSize is not foundfunction nvmlDeviceSetCpuAffinity is not foundfunction nvmlDeviceSetDefaultAutoBoostedClocksEnabled is not foundfunction nvmlDeviceSetDefaultFanSpeed_v2 is not foundfunction nvmlDeviceSetDramEncryptionMode is not foundfunction nvmlDeviceSetDriverModel is not foundfunction nvmlDeviceSetEccMode is not foundfunction nvmlDeviceSetFanControlPolicy is not foundfunction nvmlDeviceSetFanSpeed_v2 is not foundfunction nvmlDeviceSetGpuLockedClocks is not foundfunction nvmlDeviceSetGpuOperationMode is not foundfunction nvmlDeviceSetHostname_v1 is not foundfunction nvmlDeviceSetMemoryLockedClocks is not foundfunction ""nvmlDeviceSetMigMode is not foundfunction nvmlDeviceSetNvLinkDeviceLowPowerThreshold is not foundfunction nvmlDeviceSetNvlinkBwMode is not foundfunction nvmlDeviceSetPersistenceMode is not foundfunction nvmlDeviceSetPowerManagementLimit is not foundfunction nvmlDeviceSetPowerManagementLimit_v2 is not foundfunction nvmlDeviceSetPowerMizerMode_v1 is not foundfunction nvmlDeviceSetTemperatureThreshold is not foundfunction nvmlDeviceSetVgpuCapabilities is not foundfunction nvmlDeviceSetVgpuHeterogeneousMode is not foundfunction nvmlDeviceSetVgpuSchedulerState is not foundfunction nvmlDeviceSetVirtualizationMode is not foundfunction nvmlDeviceValidateInforom is not foundfunction nvmlDeviceWorkloadPowerProfileClearRequestedProfiles is not foundfunction nvmlErrorString is not foundfunction nvmlEventSetCreate is not foundfunction nvmlEventSetFree is not foundfunction nvmlEventSetWait_v2 is not foundfunction nvmlGetExcludedDeviceCount is not foundfunction nvmlGetExcludedDeviceInfoByIndex is not foundfunction nvmlGetVgpuCompatibility is not foundfunction nvmlGetVgpuDriverCapabilities is not foundfunction nvmlGetVgpuVersion is not foundfunction nvmlGpmMigSampleGet is not foundfunction nvmlGpmQueryDeviceSupport is not foundfunction nvmlGpmQueryIfStreamingEnabled is not foundfunction nvmlGpmSampleGet is not foundfunction nvmlGpmSetStreamingEnabled is not foundfunction nvmlGpuInstanceCreateComputeInstance is not foundfunction nvmlGpuInstanceCreateComputeInstanceWithPlacement is not foundfunction nvmlGpuInstanceDestroy is not foundfunction nvmlGpuInstanceGetActiveVgpus is not foundfunction nvmlGpuInstanceGetComputeInstanceProfileInfoV is not foundfunction nvmlGpuInstanceGetComputeInstanceRemainingCapacity is not foundfunction nvmlGpuInstanceGetComputeInstancePossiblePlacements is not foundfunction nvmlGpuInstanceGetComputeInstances is not foundfunction nvmlGpuInstanceGetComputeInstanceById is not foundfunction nvmlGpuInstanceGetCreatableVgpus is not foundfunction nvmlGpuInstanceGe""tInfo is not foundfunction nvmlGpuInstanceGetVgpuHeterogeneousMode is not foundfunction nvmlGpuInstanceGetVgpuSchedulerState is not foundfunction nvmlGpuInstanceGetVgpuSchedulerLog is not foundfunction nvmlGpuInstanceGetVgpuTypeCreatablePlacements is not foundfunction nvmlGpuInstanceSetVgpuHeterogeneousMode is not foundfunction nvmlGpuInstanceSetVgpuSchedulerState is not foundfunction nvmlInitWithFlags is not foundfunction nvmlInit_v2 is not foundfunction nvmlSetVgpuVersion is not foundfunction nvmlShutdown is not foundfunction nvmlSystemEventSetCreate is not foundfunction nvmlSystemEventSetFree is not foundfunction nvmlSystemEventSetWait is not foundfunction nvmlSystemGetConfComputeCapabilities is not foundfunction nvmlSystemGetConfComputeState is not foundfunction nvmlSystemGetConfComputeGpusReadyState is not foundfunction nvmlSystemGetConfComputeKeyRotationThresholdInfo is not foundfunction nvmlSystemGetConfComputeSettings is not foundfunction nvmlSystemGetCudaDriverVersion is not foundfunction nvmlSystemGetCudaDriverVersion_v2 is not foundfunction nvmlSystemGetDriverBranch is not foundfunction nvmlSystemGetDriverVersion is not foundfunction nvmlSystemGetHicVersion is not foundfunction nvmlSystemGetNVMLVersion is not foundfunction nvmlSystemGetNvlinkBwMode is not foundfunction nvmlSystemGetProcessName is not foundfunction nvmlSystemGetTopologyGpuSet is not foundfunction nvmlSystemRegisterEvents is not foundfunction nvmlSystemSetConfComputeGpusReadyState is not foundfunction nvmlSystemSetConfComputeKeyRotationThresholdInfo is not foundfunction nvmlSystemSetNvlinkBwMode is not foundfunction nvmlUnitGetCount is not foundfunction nvmlUnitGetDevices is not foundfunction nvmlUnitGetFanSpeedInfo is not foundfunction nvmlUnitGetHandleByIndex is not foundfunction nvmlUnitGetLedState is not foundfunction nvmlUnitGetPsuInfo is not foundfunction nvmlUnitGetTemperature is not foundfunction nvmlUnitGetUnitInfo is not foundfunction nvmlUnitSetLedState is not foundfunction nvmlV""gpuInstanceClearAccountingPids is not foundfunction nvmlVgpuInstanceGetAccountingMode is not foundfunction nvmlVgpuInstanceGetAccountingPids is not foundfunction nvmlVgpuInstanceGetAccountingStats is not foundfunction nvmlVgpuInstanceGetEccMode is not foundfunction nvmlVgpuInstanceGetEncoderCapacity is not foundfunction nvmlVgpuInstanceGetEncoderStats is not foundfunction nvmlVgpuInstanceGetEncoderSessions is not foundfunction nvmlVgpuInstanceGetFBCStats is not foundfunction nvmlVgpuInstanceGetFBCSessions is not foundfunction nvmlVgpuInstanceGetFbUsage is not foundfunction nvmlVgpuInstanceGetFrameRateLimit is not foundfunction nvmlVgpuInstanceGetGpuInstanceId is not foundfunction nvmlVgpuInstanceGetGpuPciId is not foundfunction nvmlVgpuInstanceGetLicenseStatus is not foundfunction nvmlVgpuInstanceGetLicenseInfo_v2 is not foundfunction nvmlVgpuInstanceGetMdevUUID is not foundfunction nvmlVgpuInstanceGetMetadata is not foundfunction nvmlVgpuInstanceGetPlacementId is not foundfunction nvmlVgpuInstanceGetRuntimeStateSize is not foundfunction nvmlVgpuInstanceGetType is not foundfunction nvmlVgpuInstanceGetUUID is not foundfunction nvmlVgpuInstanceGetVmDriverVersion is not foundfunction nvmlVgpuInstanceGetVmID is not foundfunction nvmlVgpuInstanceSetEncoderCapacity is not foundfunction nvmlVgpuTypeGetBAR1Info is not foundfunction nvmlVgpuTypeGetCapabilities is not foundfunction nvmlVgpuTypeGetClass is not foundfunction nvmlVgpuTypeGetDeviceID is not foundfunction nvmlVgpuTypeGetFbReservation is not foundfunction nvmlVgpuTypeGetFrameRateLimit is not foundfunction nvmlVgpuTypeGetFramebufferSize is not foundfunction nvmlVgpuTypeGetGpuInstanceProfileId is not foundfunction nvmlVgpuTypeGetGspHeapSize is not foundfunction nvmlVgpuTypeGetLicense is not foundfunction nvmlVgpuTypeGetMaxInstances is not foundfunction nvmlVgpuTypeGetMaxInstancesPerVm is not foundfunction nvmlVgpuTypeGetMaxInstancesPerGpuInstance is not foundfunction nvmlVgpuTypeGetName is not foundfunction nvmlVgpuT""ypeGetNumDisplayHeads is not foundfunction nvmlVgpuTypeGetResolution is not foundFunctionNotFoundErrorLockNotSupportedError__Pyx_PyDict_NextRefasyncio.coroutinescline_in_tracebackcuda.bindings._internal._nvmlcuda.pathfinder__enter____exit____func___inspect_function_pointer_inspect_function_pointers_is_coroutineitemsload_nvidia_dynamic_lib__main____module__name__name____nvmlComputeInstanceDestroy__nvmlComputeInstanceGetInfo_v2__nvmlDeviceClearAccountingPids__nvmlDeviceClearCpuAffinity__nvmlDeviceClearEccErrorCounts__nvmlDeviceClearFieldValues__nvmlDeviceCreateGpuInstanceWithPlacement__nvmlDeviceCreateGpuInstance__nvmlDeviceDiscoverGpus__nvmlDeviceGetAPIRestriction__nvmlDeviceGetAccountingBufferSize__nvmlDeviceGetAccountingMode__nvmlDeviceGetAccountingPids__nvmlDeviceGetAccountingStats__nvmlDeviceGetActiveVgpus__nvmlDeviceGetAdaptiveClockInfoStatus__nvmlDeviceGetAddressingMode__nvmlDeviceGetArchitecture__nvmlDeviceGetAttributes_v2__nvmlDeviceGetAutoBoostedClocksEnabled__nvmlDeviceGetBAR1MemoryInfo__nvmlDeviceGetBoardId__nvmlDeviceGetBoardPartNumber__nvmlDeviceGetBrand__nvmlDeviceGetBridgeChipInfo__nvmlDeviceGetBusType__nvmlDeviceGetC2cModeInfoV__nvmlDeviceGetCapabilities__nvmlDeviceGetClkMonStatus__nvmlDeviceGetClockInfo__nvmlDeviceGetClockOffsets__nvmlDeviceGetClock__nvmlDeviceGetComputeInstanceId__nvmlDeviceGetComputeMode__nvmlDeviceGetComputeRunningProcesses_v3__nvmlDeviceGetConfComputeGpuAttestationReport__nvmlDeviceGetConfComputeGpuCertificate__nvmlDeviceGetConfComputeMemSizeInfo__nvmlDeviceGetConfComputeProtectedMemoryUsage__nvmlDeviceGetCoolerInfo__nvmlDeviceGetCount_v2__nvmlDeviceGetCpuAffinityWithinScope__nvmlDeviceGetCpuAffinity__nvmlDeviceGetCreatableVgpus__nvmlDeviceGetCudaComputeCapability__nvmlDeviceGetCurrPcieLinkGeneration__nvmlDeviceGetCurrPcieLinkWidth__nvmlDeviceGetCurrentClockFreqs__nvmlDeviceGetCurrentClocksEventReasons__nvmlDeviceGetDecoderUtilization__nvmlDeviceGetDefaultEccMode__nvmlDeviceGetDeviceHandleFromMigDeviceHandle__nvmlDeviceGetDisplay""Active__nvmlDeviceGetDisplayMode__nvmlDeviceGetDramEncryptionMode__nvmlDeviceGetDriverModel_v2__nvmlDeviceGetDynamicPstatesInfo__nvmlDeviceGetEccMode__nvmlDeviceGetEncoderCapacity__nvmlDeviceGetEncoderSessions__nvmlDeviceGetEncoderStats__nvmlDeviceGetEncoderUtilization__nvmlDeviceGetEnforcedPowerLimit__nvmlDeviceGetFBCSessions__nvmlDeviceGetFBCStats__nvmlDeviceGetFanControlPolicy_v2__nvmlDeviceGetFanSpeedRPM__nvmlDeviceGetFanSpeed__nvmlDeviceGetFanSpeed_v2__nvmlDeviceGetFieldValues__nvmlDeviceGetGpcClkMinMaxVfOffset__nvmlDeviceGetGpcClkVfOffset__nvmlDeviceGetGpuFabricInfoV__nvmlDeviceGetGpuInstanceById__nvmlDeviceGetGpuInstanceId__nvmlDeviceGetGpuInstancePossiblePlacements_v2__nvmlDeviceGetGpuInstanceProfileInfoV__nvmlDeviceGetGpuInstanceProfileInfoByIdV__nvmlDeviceGetGpuInstanceRemainingCapacity__nvmlDeviceGetGpuInstances__nvmlDeviceGetGpuMaxPcieLinkGeneration__nvmlDeviceGetGpuOperationMode__nvmlDeviceGetGridLicensableFeatures_v4__nvmlDeviceGetGspFirmwareMode__nvmlDeviceGetGspFirmwareVersion__nvmlDeviceGetHandleByIndex_v2__nvmlDeviceGetHandleByPciBusId_v2__nvmlDeviceGetHandleBySerial__nvmlDeviceGetHandleByUUIDV__nvmlDeviceGetHandleByUUID__nvmlDeviceGetHostVgpuMode__nvmlDeviceGetHostname_v1__nvmlDeviceGetIndex__nvmlDeviceGetInforomConfigurationChecksum__nvmlDeviceGetInforomImageVersion__nvmlDeviceGetInforomVersion__nvmlDeviceGetIrqNum__nvmlDeviceGetJpgUtilization__nvmlDeviceGetLastBBXFlushTime__nvmlDeviceGetMPSComputeRunningProcesses_v3__nvmlDeviceGetMarginTemperature__nvmlDeviceGetMaxClockInfo__nvmlDeviceGetMaxCustomerBoostClock__nvmlDeviceGetMaxMigDeviceCount__nvmlDeviceGetMaxPcieLinkGeneration__nvmlDeviceGetMaxPcieLinkWidth__nvmlDeviceGetMemClkMinMaxVfOffset__nvmlDeviceGetMemClkVfOffset__nvmlDeviceGetMemoryAffinity__nvmlDeviceGetMemoryBusWidth__nvmlDeviceGetMemoryErrorCounter__nvmlDeviceGetMemoryInfo_v2__nvmlDeviceGetMigDeviceHandleByIndex__nvmlDeviceGetMigMode__nvmlDeviceGetMinMaxClockOfPState__nvmlDeviceGetMinMaxFanSpeed__nvmlDeviceGetMinorNumber__nvmlDeviceGet""ModuleId__nvmlDeviceGetMultiGpuBoard__nvmlDeviceGetName__nvmlDeviceGetNumFans__nvmlDeviceGetNumGpuCores__nvmlDeviceGetNumaNodeId__nvmlDeviceGetNvLinkCapability__nvmlDeviceGetNvLinkErrorCounter__nvmlDeviceGetNvLinkInfo__nvmlDeviceGetNvLinkRemoteDeviceType__nvmlDeviceGetNvLinkRemotePciInfo_v2__nvmlDeviceGetNvLinkState__nvmlDeviceGetNvLinkVersion__nvmlDeviceGetNvlinkBwMode__nvmlDeviceGetNvlinkSupportedBwModes__nvmlDeviceGetOfaUtilization__nvmlDeviceGetP2PStatus__nvmlDeviceGetPciInfoExt__nvmlDeviceGetPciInfo_v3__nvmlDeviceGetPcieLinkMaxSpeed__nvmlDeviceGetPcieReplayCounter__nvmlDeviceGetPcieSpeed__nvmlDeviceGetPcieThroughput__nvmlDeviceGetPdi__nvmlDeviceGetPerformanceModes__nvmlDeviceGetPerformanceState__nvmlDeviceGetPersistenceMode__nvmlDeviceGetPgpuMetadataString__nvmlDeviceGetPlatformInfo__nvmlDeviceGetPowerManagementDefaultLimit__nvmlDeviceGetPowerManagementLimit__nvmlDeviceGetPowerManagementLimitConstraints__nvmlDeviceGetPowerMizerMode_v1__nvmlDeviceGetPowerSource__nvmlDeviceGetPowerState__nvmlDeviceGetPowerUsage__nvmlDeviceGetProcessUtilization__nvmlDeviceGetProcessesUtilizationInfo__nvmlDeviceGetRemappedRows__nvmlDeviceGetRepairStatus__nvmlDeviceGetRetiredPagesPendingStatus__nvmlDeviceGetRetiredPages__nvmlDeviceGetRetiredPages_v2__nvmlDeviceGetRowRemapperHistogram__nvmlDeviceGetRunningProcessDetailList__nvmlDeviceGetSamples__nvmlDeviceGetSerial__nvmlDeviceGetSramEccErrorStatus__nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts__nvmlDeviceGetSupportedClocksEventReasons__nvmlDeviceGetSupportedEventTypes__nvmlDeviceGetSupportedGraphicsClocks__nvmlDeviceGetSupportedMemoryClocks__nvmlDeviceGetSupportedPerformanceStates__nvmlDeviceGetSupportedVgpus__nvmlDeviceGetTargetFanSpeed__nvmlDeviceGetTemperatureThreshold__nvmlDeviceGetTemperatureV__nvmlDeviceGetThermalSettings__nvmlDeviceGetTopologyCommonAncestor__nvmlDeviceGetTopologyNearestGpus__nvmlDeviceGetTotalEccErrors__nvmlDeviceGetTotalEnergyConsumption__nvmlDeviceGetUUID__nvmlDeviceGetUtilizationRates__nvmlDeviceGetVbios""Version__nvmlDeviceGetVgpuCapabilities__nvmlDeviceGetVgpuHeterogeneousMode__nvmlDeviceGetVgpuInstancesUtilizationInfo__nvmlDeviceGetVgpuMetadata__nvmlDeviceGetVgpuProcessUtilization__nvmlDeviceGetVgpuProcessesUtilizationInfo__nvmlDeviceGetVgpuSchedulerCapabilities__nvmlDeviceGetVgpuSchedulerLog__nvmlDeviceGetVgpuSchedulerState__nvmlDeviceGetVgpuTypeCreatablePlacements__nvmlDeviceGetVgpuTypeSupportedPlacements__nvmlDeviceGetVgpuUtilization__nvmlDeviceGetVirtualizationMode__nvmlDeviceIsMigDeviceHandle__nvmlDeviceModifyDrainState__nvmlDeviceOnSameBoard__nvmlDevicePowerSmoothingActivatePresetProfile__nvmlDevicePowerSmoothingSetState__nvmlDevicePowerSmoothingUpdatePresetProfileParam__nvmlDeviceQueryDrainState__nvmlDeviceReadWritePRM_v1__nvmlDeviceRegisterEvents__nvmlDeviceRemoveGpu_v2__nvmlDeviceResetGpuLockedClocks__nvmlDeviceResetMemoryLockedClocks__nvmlDeviceResetNvLinkErrorCounters__nvmlDeviceSetAPIRestriction__nvmlDeviceSetAccountingMode__nvmlDeviceSetAutoBoostedClocksEnabled__nvmlDeviceSetClockOffsets__nvmlDeviceSetComputeMode__nvmlDeviceSetConfComputeUnprotectedMemSize__nvmlDeviceSetCpuAffinity__nvmlDeviceSetDefaultAutoBoostedClocksEnabled__nvmlDeviceSetDefaultFanSpeed_v2__nvmlDeviceSetDramEncryptionMode__nvmlDeviceSetDriverModel__nvmlDeviceSetEccMode__nvmlDeviceSetFanControlPolicy__nvmlDeviceSetFanSpeed_v2__nvmlDeviceSetGpuLockedClocks__nvmlDeviceSetGpuOperationMode__nvmlDeviceSetHostname_v1__nvmlDeviceSetMemoryLockedClocks__nvmlDeviceSetMigMode__nvmlDeviceSetNvLinkDeviceLowPowerThreshold__nvmlDeviceSetNvlinkBwMode__nvmlDeviceSetPersistenceMode__nvmlDeviceSetPowerManagementLimit__nvmlDeviceSetPowerManagementLimit_v2__nvmlDeviceSetPowerMizerMode_v1__nvmlDeviceSetTemperatureThreshold__nvmlDeviceSetVgpuCapabilities__nvmlDeviceSetVgpuHeterogeneousMode__nvmlDeviceSetVgpuSchedulerState__nvmlDeviceSetVirtualizationMode__nvmlDeviceValidateInforom__nvmlDeviceWorkloadPowerProfileClearRequestedProfiles__nvmlErrorString__nvmlEventSetCreate__nvmlEventSetFree__nvmlEventSetWait""_v2__nvmlGetExcludedDeviceCount__nvmlGetExcludedDeviceInfoByIndex__nvmlGetVgpuCompatibility__nvmlGetVgpuDriverCapabilities__nvmlGetVgpuVersion__nvmlGpmMigSampleGet__nvmlGpmQueryDeviceSupport__nvmlGpmQueryIfStreamingEnabled__nvmlGpmSampleGet__nvmlGpmSetStreamingEnabled__nvmlGpuInstanceCreateComputeInstance__nvmlGpuInstanceCreateComputeInstanceWithPlacement__nvmlGpuInstanceDestroy__nvmlGpuInstanceGetActiveVgpus__nvmlGpuInstanceGetComputeInstanceProfileInfoV__nvmlGpuInstanceGetComputeInstanceRemainingCapacity__nvmlGpuInstanceGetComputeInstancePossiblePlacements__nvmlGpuInstanceGetComputeInstances__nvmlGpuInstanceGetComputeInstanceById__nvmlGpuInstanceGetCreatableVgpus__nvmlGpuInstanceGetInfo__nvmlGpuInstanceGetVgpuHeterogeneousMode__nvmlGpuInstanceGetVgpuSchedulerState__nvmlGpuInstanceGetVgpuSchedulerLog__nvmlGpuInstanceGetVgpuTypeCreatablePlacements__nvmlGpuInstanceSetVgpuHeterogeneousMode__nvmlGpuInstanceSetVgpuSchedulerState__nvmlInitWithFlags__nvmlInit_v2__nvmlSetVgpuVersion__nvmlShutdown__nvmlSystemEventSetCreate__nvmlSystemEventSetFree__nvmlSystemEventSetWait__nvmlSystemGetConfComputeCapabilities__nvmlSystemGetConfComputeGpusReadyState__nvmlSystemGetConfComputeKeyRotationThresholdInfo__nvmlSystemGetConfComputeSettings__nvmlSystemGetConfComputeState__nvmlSystemGetCudaDriverVersion__nvmlSystemGetCudaDriverVersion_v2__nvmlSystemGetDriverBranch__nvmlSystemGetDriverVersion__nvmlSystemGetHicVersion__nvmlSystemGetNVMLVersion__nvmlSystemGetNvlinkBwMode__nvmlSystemGetProcessName__nvmlSystemGetTopologyGpuSet__nvmlSystemRegisterEvents__nvmlSystemSetConfComputeGpusReadyState__nvmlSystemSetConfComputeKeyRotationThresholdInfo__nvmlSystemSetNvlinkBwMode__nvmlUnitGetCount__nvmlUnitGetDevices__nvmlUnitGetFanSpeedInfo__nvmlUnitGetHandleByIndex__nvmlUnitGetLedState__nvmlUnitGetPsuInfo__nvmlUnitGetTemperature__nvmlUnitGetUnitInfo__nvmlUnitSetLedState__nvmlVgpuInstanceClearAccountingPids__nvmlVgpuInstanceGetAccountingMode__nvmlVgpuInstanceGetAccountingPids__nvmlVgpuInstanceGetAccount""ingStats__nvmlVgpuInstanceGetEccMode__nvmlVgpuInstanceGetEncoderCapacity__nvmlVgpuInstanceGetEncoderSessions__nvmlVgpuInstanceGetEncoderStats__nvmlVgpuInstanceGetFBCSessions__nvmlVgpuInstanceGetFBCStats__nvmlVgpuInstanceGetFbUsage__nvmlVgpuInstanceGetFrameRateLimit__nvmlVgpuInstanceGetGpuInstanceId__nvmlVgpuInstanceGetGpuPciId__nvmlVgpuInstanceGetLicenseInfo_v2__nvmlVgpuInstanceGetLicenseStatus__nvmlVgpuInstanceGetMdevUUID__nvmlVgpuInstanceGetMetadata__nvmlVgpuInstanceGetPlacementId__nvmlVgpuInstanceGetRuntimeStateSize__nvmlVgpuInstanceGetType__nvmlVgpuInstanceGetUUID__nvmlVgpuInstanceGetVmDriverVersion__nvmlVgpuInstanceGetVmID__nvmlVgpuInstanceSetEncoderCapacity__nvmlVgpuTypeGetBAR1Info__nvmlVgpuTypeGetCapabilities__nvmlVgpuTypeGetClass__nvmlVgpuTypeGetDeviceID__nvmlVgpuTypeGetFbReservation__nvmlVgpuTypeGetFrameRateLimit__nvmlVgpuTypeGetFramebufferSize__nvmlVgpuTypeGetGpuInstanceProfileId__nvmlVgpuTypeGetGspHeapSize__nvmlVgpuTypeGetLicense__nvmlVgpuTypeGetMaxInstancesPerVm__nvmlVgpuTypeGetMaxInstancesPerGpuInstance__nvmlVgpuTypeGetMaxInstances__nvmlVgpuTypeGetName__nvmlVgpuTypeGetNumDisplayHeads__nvmlVgpuTypeGetResolutionpop__pyx_capi____qualname____set_name__setdefault__test__threadingutilsvalueschar const *(nvmlReturn_t)\000nvmlReturn_t (char *, unsigned int)\000\000nvmlReturn_t (char const *, nvmlDevice_t *)\000\000\000nvmlReturn_t (int *)\000\000nvmlReturn_t (nvmlComputeInstance_t)\000nvmlReturn_t (nvmlComputeInstance_t, nvmlComputeInstanceInfo_t *)\000nvmlReturn_t (nvmlConfComputeGetKeyRotationThresholdInfo_t *)\000nvmlReturn_t (nvmlConfComputeSetKeyRotationThresholdInfo_t *)\000nvmlReturn_t (nvmlConfComputeSystemCaps_t *)\000nvmlReturn_t (nvmlConfComputeSystemState_t *)\000nvmlReturn_t (nvmlDevice_t)\000\000\000\000\000\000nvmlReturn_t (nvmlDevice_t, char *)\000nvmlReturn_t (nvmlDevice_t, char *, unsigned int *)\000nvmlReturn_t (nvmlDevice_t, char *, unsigned int)\000\000\000\000\000\000nvmlReturn_t (nvmlDevice_t, int *)\000\000nvmlReturn_t (nvmlDevice_t, int"" *, int *)\000\000\000nvmlReturn_t (nvmlDevice_t, int, nvmlFieldValue_t *)\000\000nvmlReturn_t (nvmlDevice_t, nvmlBAR1Memory_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlBrandType_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlBridgeChipHierarchy_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlBusType_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlC2cModeInfo_v1_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlClkMonStatus_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlClockOffset_t *)\000\000nvmlReturn_t (nvmlDevice_t, nvmlClockType_t, nvmlClockId_t, unsigned int *)\000nvmlReturn_t (nvmlDevice_t, nvmlClockType_t, nvmlPstates_t, unsigned int *, unsigned int *)\000nvmlReturn_t (nvmlDevice_t, nvmlClockType_t, unsigned int *)\000\000\000nvmlReturn_t (nvmlDevice_t, nvmlComputeMode_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlComputeMode_t)\000nvmlReturn_t (nvmlDevice_t, nvmlConfComputeGpuAttestationReport_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlConfComputeGpuCertificate_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlConfComputeMemSizeInfo_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlCoolerInfo_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlDeviceAddressingMode_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlDeviceArchitecture_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlDeviceAttributes_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlDeviceCapabilities_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlDeviceCurrentClockFreqs_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlDevicePerfModes_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlDevicePowerMizerModes_v1_t *)\000\000nvmlReturn_t (nvmlDevice_t, nvmlDeviceVgpuCapability_t, nvmlEnableState_t)\000nvmlReturn_t (nvmlDevice_t, nvmlDeviceVgpuCapability_t, unsigned int *)\000nvmlReturn_t (nvmlDevice_t, nvmlDevice_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlDevice_t, int *)\000nvmlReturn_t (nvmlDevice_t, nvmlDevice_t, nvmlGpuP2PCapsIndex_t, nvmlGpuP2PStatus_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlDevice_t, nvmlGpuTopologyLevel_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlDramEncryptionInfo_t *, nvmlDramEncryptionInfo_t *)\000nvmlReturn_t (nvmlDe""vice_t, nvmlDramEncryptionInfo_t const *)\000nvmlReturn_t (nvmlDevice_t, nvmlDriverModel_t *, nvmlDriverModel_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlDriverModel_t, unsigned int)\000nvmlReturn_t (nvmlDevice_t, nvmlEccCounterType_t)\000nvmlReturn_t (nvmlDevice_t, nvmlEccSramErrorStatus_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlEccSramUniqueUncorrectedErrorCounts_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlEnableState_t *)\000\000\000\000\000\000nvmlReturn_t (nvmlDevice_t, nvmlEnableState_t *, nvmlEnableState_t *)\000\000nvmlReturn_t (nvmlDevice_t, nvmlEnableState_t)\000\000\000\000nvmlReturn_t (nvmlDevice_t, nvmlEnableState_t, unsigned int)\000nvmlReturn_t (nvmlDevice_t, nvmlEncoderType_t, unsigned int *)\000nvmlReturn_t (nvmlDevice_t, nvmlFBCStats_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlFanSpeedInfo_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlGpmSample_t)\000nvmlReturn_t (nvmlDevice_t, nvmlGpmSupport_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlGpuDynamicPstatesInfo_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlGpuFabricInfoV_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlGpuOperationMode_t *, nvmlGpuOperationMode_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlGpuOperationMode_t)\000nvmlReturn_t (nvmlDevice_t, nvmlGpuTopologyLevel_t, unsigned int *, nvmlDevice_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlGpuVirtualizationMode_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlGpuVirtualizationMode_t)\000nvmlReturn_t (nvmlDevice_t, nvmlGridLicensableFeatures_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlHostVgpuMode_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlHostname_v1_t *)\000\000nvmlReturn_t (nvmlDevice_t, nvmlInforomObject_t, char *, unsigned int)\000nvmlReturn_t (nvmlDevice_t, nvmlMarginTemperature_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlMemoryErrorType_t, nvmlEccCounterType_t, nvmlMemoryLocation_t, unsigned PY_LONG_LONG *)\000nvmlReturn_t (nvmlDevice_t, nvmlMemoryErrorType_t, nvmlEccCounterType_t, unsigned PY_LONG_LONG *)\000nvmlReturn_t (nvmlDevice_t, nvmlMemory_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlMemory_v2_t *)""\000nvmlReturn_t (nvmlDevice_t, nvmlNvLinkInfo_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlNvLinkPowerThres_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlNvlinkGetBwMode_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlNvlinkSetBwMode_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlNvlinkSupportedBwModes_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlPRMTLV_v1_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlPageRetirementCause_t, unsigned int *, unsigned PY_LONG_LONG *)\000nvmlReturn_t (nvmlDevice_t, nvmlPageRetirementCause_t, unsigned int *, unsigned PY_LONG_LONG *, unsigned PY_LONG_LONG *)\000nvmlReturn_t (nvmlDevice_t, nvmlPciInfoExt_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlPciInfo_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlPcieUtilCounter_t, unsigned int *)\000nvmlReturn_t (nvmlDevice_t, nvmlPdi_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlPlatformInfo_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlPowerSmoothingProfile_t *)\000\000nvmlReturn_t (nvmlDevice_t, nvmlPowerSmoothingState_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlPowerSource_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlPowerValue_v2_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlProcessDetailList_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlProcessUtilizationSample_t *, unsigned int *, unsigned PY_LONG_LONG)\000nvmlReturn_t (nvmlDevice_t, nvmlProcessesUtilizationInfo_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlPstates_t *)\000\000nvmlReturn_t (nvmlDevice_t, nvmlPstates_t *, unsigned int)\000nvmlReturn_t (nvmlDevice_t, nvmlRepairStatus_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlRestrictedAPI_t, nvmlEnableState_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlRestrictedAPI_t, nvmlEnableState_t)\000nvmlReturn_t (nvmlDevice_t, nvmlRowRemapperHistogramValues_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlSamplingType_t, unsigned PY_LONG_LONG, nvmlValueType_t *, unsigned int *, nvmlSample_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlTemperatureThresholds_t, int *)\000nvmlReturn_t (nvmlDevice_t, nvmlTemperatureThresholds_t, unsigned int *)\000nvmlReturn_t (nvmlDevice_t, nvmlTemperature_t *)\000nvmlReturn_t (nvm""lDevice_t, nvmlUtilization_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlVgpuHeterogeneousMode_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlVgpuHeterogeneousMode_t const *)\000nvmlReturn_t (nvmlDevice_t, nvmlVgpuInstancesUtilizationInfo_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlVgpuPgpuMetadata_t *, unsigned int *)\000nvmlReturn_t (nvmlDevice_t, nvmlVgpuProcessesUtilizationInfo_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlVgpuSchedulerCapabilities_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlVgpuSchedulerGetState_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlVgpuSchedulerLog_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlVgpuSchedulerSetState_t *)\000nvmlReturn_t (nvmlDevice_t, nvmlVgpuTypeId_t, nvmlVgpuPlacementList_t *)\000\000nvmlReturn_t (nvmlDevice_t, nvmlVgpuTypeId_t, unsigned int *)\000nvmlReturn_t (nvmlDevice_t, nvmlWorkloadPowerProfileRequestedProfiles_t *)\000nvmlReturn_t (nvmlDevice_t, unsigned PY_LONG_LONG *)\000\000\000\000nvmlReturn_t (nvmlDevice_t, unsigned PY_LONG_LONG *, unsigned long *)\000nvmlReturn_t (nvmlDevice_t, unsigned PY_LONG_LONG)\000nvmlReturn_t (nvmlDevice_t, unsigned PY_LONG_LONG, nvmlEventSet_t)\000nvmlReturn_t (nvmlDevice_t, unsigned PY_LONG_LONG, nvmlValueType_t *, unsigned int *, nvmlVgpuInstanceUtilizationSample_t *)\000nvmlReturn_t (nvmlDevice_t, unsigned PY_LONG_LONG, unsigned int *, nvmlVgpuProcessUtilizationSample_t *)\000nvmlReturn_t (nvmlDevice_t, unsigned int *)\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000nvmlReturn_t (nvmlDevice_t, unsigned int *, nvmlEncoderSessionInfo_t *)\000nvmlReturn_t (nvmlDevice_t, unsigned int *, nvmlFBCSessionInfo_t *)\000nvmlReturn_t (nvmlDevice_t, unsigned int *, nvmlProcessInfo_t *)\000\000nvmlReturn_t (nvmlDevice_t, unsigned int *, nvmlVgpuInstance_t *)\000nvmlReturn_t (nvmlDevice_t, unsigned int *, nvmlVgpuTypeId_t *)\000\000nvmlReturn_t (nvmlDevice_t, unsigned int *, unsigned int *)\000\000\000\000\000\000\000\000\000\000nvmlReturn_t (nvmlDevice_t, u""nsigned int *, unsigned int *, unsigned int *)\000nvmlReturn_t (nvmlDevice_t, unsigned int *, unsigned int *, unsigned int *, unsigned int *)\000nvmlReturn_t (nvmlDevice_t, unsigned int)\000\000\000\000nvmlReturn_t (nvmlDevice_t, unsigned int, nvmlAccountingStats_t *)\000nvmlReturn_t (nvmlDevice_t, unsigned int, nvmlDevice_t *)\000nvmlReturn_t (nvmlDevice_t, unsigned int, nvmlEnableState_t *)\000nvmlReturn_t (nvmlDevice_t, unsigned int, nvmlFanControlPolicy_t *)\000nvmlReturn_t (nvmlDevice_t, unsigned int, nvmlFanControlPolicy_t)\000nvmlReturn_t (nvmlDevice_t, unsigned int, nvmlGpmSample_t)\000nvmlReturn_t (nvmlDevice_t, unsigned int, nvmlGpuInstancePlacement_t *, unsigned int *)\000nvmlReturn_t (nvmlDevice_t, unsigned int, nvmlGpuInstancePlacement_t const *, nvmlGpuInstance_t *)\000nvmlReturn_t (nvmlDevice_t, unsigned int, nvmlGpuInstanceProfileInfo_v2_t *)\000\000nvmlReturn_t (nvmlDevice_t, unsigned int, nvmlGpuInstance_t *)\000\000nvmlReturn_t (nvmlDevice_t, unsigned int, nvmlGpuInstance_t *, unsigned int *)\000nvmlReturn_t (nvmlDevice_t, unsigned int, nvmlGpuThermalSettings_t *)\000nvmlReturn_t (nvmlDevice_t, unsigned int, nvmlIntNvLinkDeviceType_t *)\000nvmlReturn_t (nvmlDevice_t, unsigned int, nvmlNvLinkCapability_t, unsigned int *)\000nvmlReturn_t (nvmlDevice_t, unsigned int, nvmlNvLinkErrorCounter_t, unsigned PY_LONG_LONG *)\000nvmlReturn_t (nvmlDevice_t, unsigned int, nvmlPciInfo_t *)\000nvmlReturn_t (nvmlDevice_t, unsigned int, nvmlReturn_t *)\000nvmlReturn_t (nvmlDevice_t, unsigned int, unsigned int *)\000\000\000\000nvmlReturn_t (nvmlDevice_t, unsigned int, unsigned int *, unsigned int *)\000nvmlReturn_t (nvmlDevice_t, unsigned int, unsigned int)\000\000\000nvmlReturn_t (nvmlDevice_t, unsigned int, unsigned long *)\000nvmlReturn_t (nvmlDevice_t, unsigned int, unsigned long *, nvmlAffinityScope_t)\000\000nvmlReturn_t (nvmlEventSet_t *)\000nvmlReturn_t (nvmlEventSet_t)\000nvmlReturn_t (nvmlEventSet_t, nvmlEventData_t *, unsigned int)\000nvmlReturn_t (nvmlG""puInstance_t)\000nvmlReturn_t (nvmlGpuInstance_t, nvmlActiveVgpuInstanceInfo_t *)\000nvmlReturn_t (nvmlGpuInstance_t, nvmlGpuInstanceInfo_t *)\000nvmlReturn_t (nvmlGpuInstance_t, nvmlVgpuCreatablePlacementInfo_t *)\000nvmlReturn_t (nvmlGpuInstance_t, nvmlVgpuHeterogeneousMode_t *)\000nvmlReturn_t (nvmlGpuInstance_t, nvmlVgpuHeterogeneousMode_t const *)\000nvmlReturn_t (nvmlGpuInstance_t, nvmlVgpuSchedulerLogInfo_t *)\000nvmlReturn_t (nvmlGpuInstance_t, nvmlVgpuSchedulerStateInfo_t *)\000nvmlReturn_t (nvmlGpuInstance_t, nvmlVgpuSchedulerState_t *)\000nvmlReturn_t (nvmlGpuInstance_t, nvmlVgpuTypeIdInfo_t *)\000nvmlReturn_t (nvmlGpuInstance_t, unsigned int, nvmlComputeInstancePlacement_t *, unsigned int *)\000nvmlReturn_t (nvmlGpuInstance_t, unsigned int, nvmlComputeInstancePlacement_t const *, nvmlComputeInstance_t *)\000nvmlReturn_t (nvmlGpuInstance_t, unsigned int, nvmlComputeInstance_t *)\000\000nvmlReturn_t (nvmlGpuInstance_t, unsigned int, nvmlComputeInstance_t *, unsigned int *)\000nvmlReturn_t (nvmlGpuInstance_t, unsigned int, unsigned int *)\000nvmlReturn_t (nvmlGpuInstance_t, unsigned int, unsigned int, nvmlComputeInstanceProfileInfo_v2_t *)\000nvmlReturn_t (nvmlPciInfo_t *)\000nvmlReturn_t (nvmlPciInfo_t *, nvmlDetachGpuState_t, nvmlPcieLinkState_t)\000nvmlReturn_t (nvmlPciInfo_t *, nvmlEnableState_t *)\000nvmlReturn_t (nvmlPciInfo_t *, nvmlEnableState_t)\000nvmlReturn_t (nvmlSystemConfComputeSettings_t *)\000nvmlReturn_t (nvmlSystemDriverBranchInfo_t *, unsigned int)\000nvmlReturn_t (nvmlSystemEventSetCreateRequest_t *)\000nvmlReturn_t (nvmlSystemEventSetFreeRequest_t *)\000nvmlReturn_t (nvmlSystemEventSetWaitRequest_t *)\000nvmlReturn_t (nvmlSystemRegisterEventRequest_t *)\000nvmlReturn_t (nvmlUUID_t const *, nvmlDevice_t *)\000nvmlReturn_t (nvmlUnit_t, nvmlLedColor_t)\000nvmlReturn_t (nvmlUnit_t, nvmlLedState_t *)\000nvmlReturn_t (nvmlUnit_t, nvmlPSUInfo_t *)\000nvmlReturn_t (nvmlUnit_t, nvmlUnitFanSpeeds_t *)\000nvmlReturn_t (nvmlUnit_t, nvmlUnitInfo_t *"")\000nvmlReturn_t (nvmlUnit_t, unsigned int *, nvmlDevice_t *)\000nvmlReturn_t (nvmlUnit_t, unsigned int, unsigned int *)\000nvmlReturn_t (nvmlVgpuDriverCapability_t, unsigned int *)\000nvmlReturn_t (nvmlVgpuInstance_t)\000nvmlReturn_t (nvmlVgpuInstance_t, char *, unsigned int *)\000nvmlReturn_t (nvmlVgpuInstance_t, char *, unsigned int)\000\000\000nvmlReturn_t (nvmlVgpuInstance_t, char *, unsigned int, nvmlVgpuVmIdType_t *)\000nvmlReturn_t (nvmlVgpuInstance_t, nvmlEnableState_t *)\000\000nvmlReturn_t (nvmlVgpuInstance_t, nvmlFBCStats_t *)\000nvmlReturn_t (nvmlVgpuInstance_t, nvmlVgpuLicenseInfo_t *)\000nvmlReturn_t (nvmlVgpuInstance_t, nvmlVgpuMetadata_t *, unsigned int *)\000nvmlReturn_t (nvmlVgpuInstance_t, nvmlVgpuPlacementId_t *)\000nvmlReturn_t (nvmlVgpuInstance_t, nvmlVgpuRuntimeState_t *)\000nvmlReturn_t (nvmlVgpuInstance_t, nvmlVgpuTypeId_t *)\000nvmlReturn_t (nvmlVgpuInstance_t, unsigned PY_LONG_LONG *)\000nvmlReturn_t (nvmlVgpuInstance_t, unsigned int *)\000\000\000\000nvmlReturn_t (nvmlVgpuInstance_t, unsigned int *, nvmlEncoderSessionInfo_t *)\000nvmlReturn_t (nvmlVgpuInstance_t, unsigned int *, nvmlFBCSessionInfo_t *)\000nvmlReturn_t (nvmlVgpuInstance_t, unsigned int *, unsigned int *)\000nvmlReturn_t (nvmlVgpuInstance_t, unsigned int *, unsigned int *, unsigned int *)\000nvmlReturn_t (nvmlVgpuInstance_t, unsigned int)\000nvmlReturn_t (nvmlVgpuInstance_t, unsigned int, nvmlAccountingStats_t *)\000nvmlReturn_t (nvmlVgpuMetadata_t *, nvmlVgpuPgpuMetadata_t *, nvmlVgpuPgpuCompatibility_t *)\000nvmlReturn_t (nvmlVgpuTypeId_t, char *, unsigned int *)\000\000nvmlReturn_t (nvmlVgpuTypeId_t, char *, unsigned int)\000nvmlReturn_t (nvmlVgpuTypeId_t, nvmlVgpuCapability_t, unsigned int *)\000nvmlReturn_t (nvmlVgpuTypeId_t, nvmlVgpuTypeBar1Info_t *)\000nvmlReturn_t (nvmlVgpuTypeId_t, unsigned PY_LONG_LONG *)\000\000\000nvmlReturn_t (nvmlVgpuTypeId_t, unsigned PY_LONG_LONG *, unsigned PY_LONG_LONG *)\000nvmlReturn_t (nvmlVgpuTypeId_t, unsigned int *)\000\000\000""\000nvmlReturn_t (nvmlVgpuTypeId_t, unsigned int, unsigned int *, unsigned int *)\000nvmlReturn_t (nvmlVgpuTypeMaxInstance_t *)\000nvmlReturn_t (nvmlVgpuVersion_t *)\000nvmlReturn_t (nvmlVgpuVersion_t *, nvmlVgpuVersion_t *)\000nvmlReturn_t (unsigned int *)\000\000\000\000\000nvmlReturn_t (unsigned int *, nvmlHwbcEntry_t *)\000nvmlReturn_t (unsigned int)\000\000\000nvmlReturn_t (unsigned int, char *, unsigned int)\000nvmlReturn_t (unsigned int, nvmlDevice_t *)\000nvmlReturn_t (unsigned int, nvmlExcludedDeviceInfo_t *)\000nvmlReturn_t (unsigned int, nvmlUnit_t *)\000nvmlReturn_t (unsigned int, unsigned int *, nvmlDevice_t *)\000nvmlReturn_t (void)\000\000_nvmlErrorString\000_nvmlSystemGetDriverVersion\000_nvmlSystemGetNVMLVersion\000_nvmlDeviceGetHandleByPciBusId_v2\000_nvmlDeviceGetHandleBySerial\000_nvmlDeviceGetHandleByUUID\000_nvmlSystemGetCudaDriverVersion\000_nvmlSystemGetCudaDriverVersion_v2\000_nvmlComputeInstanceDestroy\000_nvmlComputeInstanceGetInfo_v2\000_nvmlSystemGetConfComputeKeyRotationThresholdInfo\000_nvmlSystemSetConfComputeKeyRotationThresholdInfo\000_nvmlSystemGetConfComputeCapabilities\000_nvmlSystemGetConfComputeState\000_nvmlDeviceClearAccountingPids\000_nvmlDeviceClearCpuAffinity\000_nvmlDeviceResetGpuLockedClocks\000_nvmlDeviceResetMemoryLockedClocks\000_nvmlDeviceSetCpuAffinity\000_nvmlDeviceValidateInforom\000_nvmlDeviceGetGspFirmwareVersion\000_nvmlDeviceGetPgpuMetadataString\000_nvmlDeviceGetBoardPartNumber\000_nvmlDeviceGetInforomImageVersion\000_nvmlDeviceGetName\000_nvmlDeviceGetSerial\000_nvmlDeviceGetUUID\000_nvmlDeviceGetVbiosVersion\000_nvmlDeviceGetGpcClkVfOffset\000_nvmlDeviceGetMemClkVfOffset\000_nvmlDeviceGetCudaComputeCapability\000_nvmlDeviceGetGpcClkMinMaxVfOffset\000_nvmlDeviceGetMemClkMinMaxVfOffset\000_nvmlDeviceClearFieldValues\000_nvmlDeviceGetFieldValues\000_nvmlDeviceGetBAR1MemoryInfo\000_nvmlDeviceGetBrand\000_nvmlDeviceGetBridgeChipInfo\000_nvmlDeviceGetBusType\000_nvmlDeviceGetC2cModeInfoV\000_nvmlDeviceGetClkMonSt""atus\000_nvmlDeviceGetClockOffsets\000_nvmlDeviceSetClockOffsets\000_nvmlDeviceGetClock\000_nvmlDeviceGetMinMaxClockOfPState\000_nvmlDeviceGetClockInfo\000_nvmlDeviceGetMaxClockInfo\000_nvmlDeviceGetMaxCustomerBoostClock\000_nvmlDeviceGetComputeMode\000_nvmlDeviceSetComputeMode\000_nvmlDeviceGetConfComputeGpuAttestationReport\000_nvmlDeviceGetConfComputeGpuCertificate\000_nvmlDeviceGetConfComputeMemSizeInfo\000_nvmlDeviceGetCoolerInfo\000_nvmlDeviceGetAddressingMode\000_nvmlDeviceGetArchitecture\000_nvmlDeviceGetAttributes_v2\000_nvmlDeviceGetCapabilities\000_nvmlDeviceGetCurrentClockFreqs\000_nvmlDeviceGetPerformanceModes\000_nvmlDeviceGetPowerMizerMode_v1\000_nvmlDeviceSetPowerMizerMode_v1\000_nvmlDeviceSetVgpuCapabilities\000_nvmlDeviceGetVgpuCapabilities\000_nvmlDeviceGetDeviceHandleFromMigDeviceHandle\000_nvmlDeviceOnSameBoard\000_nvmlDeviceGetP2PStatus\000_nvmlDeviceGetTopologyCommonAncestor\000_nvmlDeviceGetDramEncryptionMode\000_nvmlDeviceSetDramEncryptionMode\000_nvmlDeviceGetDriverModel_v2\000_nvmlDeviceSetDriverModel\000_nvmlDeviceClearEccErrorCounts\000_nvmlDeviceGetSramEccErrorStatus\000_nvmlDeviceGetSramUniqueUncorrectedEccErrorCounts\000_nvmlDeviceGetAccountingMode\000_nvmlDeviceGetDefaultEccMode\000_nvmlDeviceGetDisplayActive\000_nvmlDeviceGetDisplayMode\000_nvmlDeviceGetPersistenceMode\000_nvmlDeviceGetRetiredPagesPendingStatus\000_nvmlDeviceGetAutoBoostedClocksEnabled\000_nvmlDeviceGetEccMode\000_nvmlDeviceSetAccountingMode\000_nvmlDeviceSetAutoBoostedClocksEnabled\000_nvmlDeviceSetEccMode\000_nvmlDeviceSetPersistenceMode\000_nvmlDeviceSetDefaultAutoBoostedClocksEnabled\000_nvmlDeviceGetEncoderCapacity\000_nvmlDeviceGetFBCStats\000_nvmlDeviceGetFanSpeedRPM\000_nvmlGpmSampleGet\000_nvmlGpmQueryDeviceSupport\000_nvmlDeviceGetDynamicPstatesInfo\000_nvmlDeviceGetGpuFabricInfoV\000_nvmlDeviceGetGpuOperationMode\000_nvmlDeviceSetGpuOperationMode\000_nvmlDeviceGetTopologyNearestGpus\000_nvmlDeviceGetVirtualizationMode\000_nvmlDeviceSetVirtualizationMode""\000_nvmlDeviceGetGridLicensableFeatures_v4\000_nvmlDeviceGetHostVgpuMode\000_nvmlDeviceGetHostname_v1\000_nvmlDeviceSetHostname_v1\000_nvmlDeviceGetInforomVersion\000_nvmlDeviceGetMarginTemperature\000_nvmlDeviceGetMemoryErrorCounter\000_nvmlDeviceGetTotalEccErrors\000_nvmlDeviceGetConfComputeProtectedMemoryUsage\000_nvmlDeviceGetMemoryInfo_v2\000_nvmlDeviceGetNvLinkInfo\000_nvmlDeviceSetNvLinkDeviceLowPowerThreshold\000_nvmlDeviceGetNvlinkBwMode\000_nvmlDeviceSetNvlinkBwMode\000_nvmlDeviceGetNvlinkSupportedBwModes\000_nvmlDeviceReadWritePRM_v1\000_nvmlDeviceGetRetiredPages\000_nvmlDeviceGetRetiredPages_v2\000_nvmlDeviceGetPciInfoExt\000_nvmlDeviceGetPciInfo_v3\000_nvmlDeviceGetPcieThroughput\000_nvmlDeviceGetPdi\000_nvmlDeviceGetPlatformInfo\000_nvmlDevicePowerSmoothingActivatePresetProfile\000_nvmlDevicePowerSmoothingUpdatePresetProfileParam\000_nvmlDevicePowerSmoothingSetState\000_nvmlDeviceGetPowerSource\000_nvmlDeviceSetPowerManagementLimit_v2\000_nvmlDeviceGetRunningProcessDetailList\000_nvmlDeviceGetProcessUtilization\000_nvmlDeviceGetProcessesUtilizationInfo\000_nvmlDeviceGetPerformanceState\000_nvmlDeviceGetPowerState\000_nvmlDeviceGetSupportedPerformanceStates\000_nvmlDeviceGetRepairStatus\000_nvmlDeviceGetAPIRestriction\000_nvmlDeviceSetAPIRestriction\000_nvmlDeviceGetRowRemapperHistogram\000_nvmlDeviceGetSamples\000_nvmlDeviceSetTemperatureThreshold\000_nvmlDeviceGetTemperatureThreshold\000_nvmlDeviceGetTemperatureV\000_nvmlDeviceGetUtilizationRates\000_nvmlDeviceGetVgpuHeterogeneousMode\000_nvmlDeviceSetVgpuHeterogeneousMode\000_nvmlDeviceGetVgpuInstancesUtilizationInfo\000_nvmlDeviceGetVgpuMetadata\000_nvmlDeviceGetVgpuProcessesUtilizationInfo\000_nvmlDeviceGetVgpuSchedulerCapabilities\000_nvmlDeviceGetVgpuSchedulerState\000_nvmlDeviceGetVgpuSchedulerLog\000_nvmlDeviceSetVgpuSchedulerState\000_nvmlDeviceGetVgpuTypeCreatablePlacements\000_nvmlDeviceGetVgpuTypeSupportedPlacements\000_nvmlVgpuTypeGetMaxInstances\000_nvmlDeviceWorkloadPowerProfileClearReq""uestedProfiles\000_nvmlDeviceGetCurrentClocksEventReasons\000_nvmlDeviceGetSupportedClocksEventReasons\000_nvmlDeviceGetSupportedEventTypes\000_nvmlDeviceGetTotalEnergyConsumption\000_nvmlDeviceGetLastBBXFlushTime\000_nvmlDeviceSetConfComputeUnprotectedMemSize\000_nvmlDeviceRegisterEvents\000_nvmlDeviceGetVgpuUtilization\000_nvmlDeviceGetVgpuProcessUtilization\000_nvmlDeviceGetAccountingBufferSize\000_nvmlDeviceGetAdaptiveClockInfoStatus\000_nvmlDeviceGetBoardId\000_nvmlDeviceGetComputeInstanceId\000_nvmlDeviceGetCurrPcieLinkGeneration\000_nvmlDeviceGetCurrPcieLinkWidth\000_nvmlDeviceGetEnforcedPowerLimit\000_nvmlDeviceGetFanSpeed\000_nvmlDeviceGetGpuInstanceId\000_nvmlDeviceGetGpuMaxPcieLinkGeneration\000_nvmlDeviceGetIndex\000_nvmlDeviceGetInforomConfigurationChecksum\000_nvmlDeviceGetIrqNum\000_nvmlDeviceGetMaxMigDeviceCount\000_nvmlDeviceGetMaxPcieLinkGeneration\000_nvmlDeviceGetMaxPcieLinkWidth\000_nvmlDeviceGetMemoryBusWidth\000_nvmlDeviceGetMinorNumber\000_nvmlDeviceGetModuleId\000_nvmlDeviceGetMultiGpuBoard\000_nvmlDeviceGetNumFans\000_nvmlDeviceGetNumGpuCores\000_nvmlDeviceGetNumaNodeId\000_nvmlDeviceGetPcieLinkMaxSpeed\000_nvmlDeviceGetPcieReplayCounter\000_nvmlDeviceGetPcieSpeed\000_nvmlDeviceGetPowerManagementDefaultLimit\000_nvmlDeviceGetPowerManagementLimit\000_nvmlDeviceGetPowerUsage\000_nvmlDeviceIsMigDeviceHandle\000_nvmlGpmQueryIfStreamingEnabled\000_nvmlDeviceGetEncoderSessions\000_nvmlDeviceGetFBCSessions\000_nvmlDeviceGetComputeRunningProcesses_v3\000_nvmlDeviceGetMPSComputeRunningProcesses_v3\000_nvmlDeviceGetActiveVgpus\000_nvmlDeviceGetCreatableVgpus\000_nvmlDeviceGetSupportedVgpus\000_nvmlDeviceGetAccountingPids\000_nvmlDeviceGetDecoderUtilization\000_nvmlDeviceGetEncoderUtilization\000_nvmlDeviceGetGspFirmwareMode\000_nvmlDeviceGetJpgUtilization\000_nvmlDeviceGetMigMode\000_nvmlDeviceGetMinMaxFanSpeed\000_nvmlDeviceGetOfaUtilization\000_nvmlDeviceGetPowerManagementLimitConstraints\000_nvmlDeviceGetSupportedMemoryClocks\000_nvmlDeviceGetEnco""derStats\000_nvmlDeviceGetRemappedRows\000_nvmlDeviceResetNvLinkErrorCounters\000_nvmlDeviceSetDefaultFanSpeed_v2\000_nvmlDeviceSetPowerManagementLimit\000_nvmlGpmSetStreamingEnabled\000_nvmlDeviceGetAccountingStats\000_nvmlDeviceGetMigDeviceHandleByIndex\000_nvmlDeviceGetNvLinkState\000_nvmlDeviceGetFanControlPolicy_v2\000_nvmlDeviceSetFanControlPolicy\000_nvmlGpmMigSampleGet\000_nvmlDeviceGetGpuInstancePossiblePlacements_v2\000_nvmlDeviceCreateGpuInstanceWithPlacement\000_nvmlDeviceGetGpuInstanceProfileInfoByIdV\000_nvmlDeviceGetGpuInstanceProfileInfoV\000_nvmlDeviceCreateGpuInstance\000_nvmlDeviceGetGpuInstanceById\000_nvmlDeviceGetGpuInstances\000_nvmlDeviceGetThermalSettings\000_nvmlDeviceGetNvLinkRemoteDeviceType\000_nvmlDeviceGetNvLinkCapability\000_nvmlDeviceGetNvLinkErrorCounter\000_nvmlDeviceGetNvLinkRemotePciInfo_v2\000_nvmlDeviceSetMigMode\000_nvmlDeviceGetFanSpeed_v2\000_nvmlDeviceGetGpuInstanceRemainingCapacity\000_nvmlDeviceGetNvLinkVersion\000_nvmlDeviceGetTargetFanSpeed\000_nvmlDeviceGetSupportedGraphicsClocks\000_nvmlDeviceSetFanSpeed_v2\000_nvmlDeviceSetGpuLockedClocks\000_nvmlDeviceSetMemoryLockedClocks\000_nvmlDeviceGetCpuAffinity\000_nvmlDeviceGetCpuAffinityWithinScope\000_nvmlDeviceGetMemoryAffinity\000_nvmlEventSetCreate\000_nvmlEventSetFree\000_nvmlEventSetWait_v2\000_nvmlGpuInstanceDestroy\000_nvmlGpuInstanceGetActiveVgpus\000_nvmlGpuInstanceGetInfo\000_nvmlGpuInstanceGetVgpuTypeCreatablePlacements\000_nvmlGpuInstanceGetVgpuHeterogeneousMode\000_nvmlGpuInstanceSetVgpuHeterogeneousMode\000_nvmlGpuInstanceGetVgpuSchedulerLog\000_nvmlGpuInstanceGetVgpuSchedulerState\000_nvmlGpuInstanceSetVgpuSchedulerState\000_nvmlGpuInstanceGetCreatableVgpus\000_nvmlGpuInstanceGetComputeInstancePossiblePlacements\000_nvmlGpuInstanceCreateComputeInstanceWithPlacement\000_nvmlGpuInstanceCreateComputeInstance\000_nvmlGpuInstanceGetComputeInstanceById\000_nvmlGpuInstanceGetComputeInstances\000_nvmlGpuInstanceGetComputeInstanceRemainingCapacity\000_nvmlGpuInstance""GetComputeInstanceProfileInfoV\000_nvmlDeviceDiscoverGpus\000_nvmlDeviceRemoveGpu_v2\000_nvmlDeviceQueryDrainState\000_nvmlDeviceModifyDrainState\000_nvmlSystemGetConfComputeSettings\000_nvmlSystemGetDriverBranch\000_nvmlSystemEventSetCreate\000_nvmlSystemEventSetFree\000_nvmlSystemEventSetWait\000_nvmlSystemRegisterEvents\000_nvmlDeviceGetHandleByUUIDV\000_nvmlUnitSetLedState\000_nvmlUnitGetLedState\000_nvmlUnitGetPsuInfo\000_nvmlUnitGetFanSpeedInfo\000_nvmlUnitGetUnitInfo\000_nvmlUnitGetDevices\000_nvmlUnitGetTemperature\000_nvmlGetVgpuDriverCapabilities\000_nvmlVgpuInstanceClearAccountingPids\000_nvmlVgpuInstanceGetGpuPciId\000_nvmlVgpuInstanceGetMdevUUID\000_nvmlVgpuInstanceGetUUID\000_nvmlVgpuInstanceGetVmDriverVersion\000_nvmlVgpuInstanceGetVmID\000_nvmlVgpuInstanceGetAccountingMode\000_nvmlVgpuInstanceGetEccMode\000_nvmlVgpuInstanceGetFBCStats\000_nvmlVgpuInstanceGetLicenseInfo_v2\000_nvmlVgpuInstanceGetMetadata\000_nvmlVgpuInstanceGetPlacementId\000_nvmlVgpuInstanceGetRuntimeStateSize\000_nvmlVgpuInstanceGetType\000_nvmlVgpuInstanceGetFbUsage\000_nvmlVgpuInstanceGetEncoderCapacity\000_nvmlVgpuInstanceGetFrameRateLimit\000_nvmlVgpuInstanceGetGpuInstanceId\000_nvmlVgpuInstanceGetLicenseStatus\000_nvmlVgpuInstanceGetEncoderSessions\000_nvmlVgpuInstanceGetFBCSessions\000_nvmlVgpuInstanceGetAccountingPids\000_nvmlVgpuInstanceGetEncoderStats\000_nvmlVgpuInstanceSetEncoderCapacity\000_nvmlVgpuInstanceGetAccountingStats\000_nvmlGetVgpuCompatibility\000_nvmlVgpuTypeGetClass\000_nvmlVgpuTypeGetName\000_nvmlVgpuTypeGetLicense\000_nvmlVgpuTypeGetCapabilities\000_nvmlVgpuTypeGetBAR1Info\000_nvmlVgpuTypeGetFbReservation\000_nvmlVgpuTypeGetFramebufferSize\000_nvmlVgpuTypeGetGspHeapSize\000_nvmlVgpuTypeGetDeviceID\000_nvmlVgpuTypeGetFrameRateLimit\000_nvmlVgpuTypeGetGpuInstanceProfileId\000_nvmlVgpuTypeGetMaxInstancesPerVm\000_nvmlVgpuTypeGetNumDisplayHeads\000_nvmlVgpuTypeGetResolution\000_nvmlVgpuTypeGetMaxInstancesPerGpuInstance\000_nvmlSetVgpuVersion\000_nvmlGetVgpuVers""ion\000_nvmlDeviceGetCount_v2\000_nvmlGetExcludedDeviceCount\000_nvmlSystemGetConfComputeGpusReadyState\000_nvmlSystemGetNvlinkBwMode\000_nvmlUnitGetCount\000_nvmlSystemGetHicVersion\000_nvmlInitWithFlags\000_nvmlSystemSetConfComputeGpusReadyState\000_nvmlSystemSetNvlinkBwMode\000_nvmlSystemGetProcessName\000_nvmlDeviceGetHandleByIndex_v2\000_nvmlGetExcludedDeviceInfoByIndex\000_nvmlUnitGetHandleByIndex\000_nvmlSystemGetTopologyGpuSet\000_nvmlInit_v2\000_nvmlShutdown\200\001\330\004\005\330\004\007\200z\220\023\220A\330\010\024\320\024.\250a\330\004\013\2109\220A\220Q\200\001\330\004\005\330\004\007\200z\220\027\230\001\330\010\017\210q\340\004\027\220q\330\004\025\220Q\340\004\005\330\004\010\210\001\320\t\034\230J\240a\340\004\005\330\004\010\210\001\320\t\"\240*\250A\340\004\005\330\004\010\210\001\320\t\035\230Z\240q\340\004\005\330\004\010\210\001\320\t \240\n\250!\340\004\005\330\004\010\210\001\320\t+\250:\260Q\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320\t/\250z\270\021\340\004\005\330\004\010\210\001\320\t2\260*\270A\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320\t(\250\n\260!\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t!\240\032\2501\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320\t$\240J\250a\340\004\005\330\004\010\210\001\320\t$\240J\250a\340\004\005\330\004\010\210\001\320\t#\240:\250Q\340\004\005\330\004\010\210\001\320\t'\240z\260\021\340\004\005\330\004\010\210\001\320\t(\250\n\260!\340\004\005\330\004\010\210\001\320\t#\240:\250Q\340\004\005\330\004\010\210\001\320\t&\240j\260\001\340\004\005\330\004\010\210\001\320\t+\250:\260Q\340\004\005\330\004\010\210\001\320\t.\250j\270\001\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t+\250:\260Q\340\004\005""\330\004\010\210\001\320\t1\260\032\2701\340\004\005\330\004\010\210\001\320\t\"\240*\250A\340\004\005\330\004\010\210\001\320\t#\240:\250Q\340\004\005\330\004\010\210\001\320\t#\240:\250Q\340\004\005\330\004\010\210\001\320\t$\240J\250a\340\004\005\330\004\010\210\001\320\t&\240j\260\001\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t4\260J\270a\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320\t+\250:\260Q\340\004\005\330\004\010\210\001\320\t(\250\n\260!\340\004\005\330\004\010\210\001\320\t4\260J\270a\340\004\005\330\004\010\210\001\320\t1\260\032\2701\340\004\005\330\004\010\210\001\320\t'\240z\260\021\340\004\005\330\004\010\210\001\320\t\"\240*\250A\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320\t-\250Z\260q\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t1\260\032\2701\340\004\005\330\004\010\210\001\320\t:\270*\300A\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t.\250j\270\001\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320\t+\250:\260Q\340\004\005\330\004\010\210\001\320\t-\250Z\260q\340\004\005\330\004\010\210\001\320\t(\250\n\260!\340\004\005\330\004\010\210\001\320\t(\250\n\260!\340\004\005\330\004\010\210\001\320\t3\260:\270Q\340\004\005\330\004\010\210\001\320\t6\260j\300\001\340\004\005\330\004\010\210\001\320\t.\250j\270\001\340\004\005\330\004\010\210\001\320\t4\260J\270a\340\004\005\330\004\010\210\001\320\t/\250z\270\021\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t/\250z\270\021\340\004\005\330\004\010\210\001\320\t'\240z\260\021\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t#\240:\250Q""\340\004\005\330\004\010\210\001\320\t3\260:\270Q\340\004\005\330\004\010\210\001\320\t3\260:\270Q\340\004\005\330\004\010\210\001\320\t5\260Z\270q\340\004\005\330\004\010\210\001\320\t6\260j\300\001\340\004\005\330\004\010\210\001\320\t&\240j\260\001\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t1\260\032\2701\340\004\005\330\004\010\210\001\320\t%\240Z\250q\340\004\005\330\004\010\210\001\320\t(\250\n\260!\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t2\260*\270A\340\004\005\330\004\010\210\001\320\t/\250z\270\021\340\004\005\330\004\010\210\001\320\t-\250Z\260q\340\004\005\330\004\010\210\001\320\t.\250j\270\001\340\004\005\330\004\010\210\001\320\t7\260z\300\021\340\004\005\330\004\010\210\001\320\t9\270\032\3001\340\004\005\330\004\010\210\001\320\t(\250\n\260!\340\004\005\330\004\010\210\001\320\t0\260\n\270!\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t1\260\032\2701\340\004\005\330\004\010\210\001\320\t8\270\n\300!\340\004\005\330\004\010\210\001\320\t2\260*\270A\340\004\005\330\004\010\210\001\320\t2\260*\270A\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t.\250j\270\001\340\004\005\330\004\010\210\001\320\t/\250z\270\021\340\004\005\330\004\010\210\001\320\t2\260*\270A\340\004\005\330\004\010\210\001\320\t=\270Z\300q\340\004\005\330\004\010\210\001\320\t9\270\032\3001\340\004\005\330\004\010\210\001\320\t(\250\n\260!\340\004\005\330\004\010\210\001\320\t4\260J\270a\340\004\005\330\004\010\210\001\320\t0\260\n\270!\340\004\005\330\004\010\210\001\320\t.\250j\270\001\340\004\005\330\004\010\210\001\320\t+\250:\260Q\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320""\t3\260:\270Q\340\004\005\330\004\010\210\001\320\t0\260\n\270!\340\004\005\330\004\010\210\001\320\t0\260\n\270!\340\004\005\330\004\010\210\001\320\t%\240Z\250q\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t%\240Z\250q\340\004\005\330\004\010\210\001\320\t+\250:\260Q\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t0\260\n\270!\340\004\005\330\004\010\210\001\320\t.\250j\270\001\340\004\005\330\004\010\210\001\320\t0\260\n\270!\340\004\005\330\004\010\210\001\320\t-\250Z\260q\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t-\250Z\260q\340\004\005\330\004\010\210\001\320\t0\260\n\270!\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t&\240j\260\001\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t8\270\n\300!\340\004\005\330\004\010\210\001\320\t;\270:\300Q\340\004\005\330\004\010\210\001\320\t6\260j\300\001\340\004\005\330\004\010\210\001\320\t&\240j\260\001\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t%\240Z\250q\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t$\240J\250a\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t.\250j\270\001\340\004\005\330\004\010\210\001\320\t'\240z\260\021\340\004\005\330\004\010\210\001\320\t5\260Z\270q\340\004\005\330\004\010\210\001\320\t%\240Z\250q\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t5\260Z\270q\340\004\005\330\004\010\210\001\320\t.\250j\270\001\340\004\005\330\004\010\210\001\320""\t4\260J\270a\340\004\005\330\004\010\210\001\320\t7\260z\300\021\340\004\005\330\004\010\210\001\320\t=\270Z\300q\340\004\005\330\004\010\210\001\320\t7\260z\300\021\340\004\005\330\004\010\210\001\320\t=\270Z\300q\340\004\005\330\004\010\210\001\320\tA\300\032\3101\340\004\005\330\004\010\210\001\320\t;\270:\300Q\340\004\005\330\004\010\210\001\320\t7\260z\300\021\340\004\005\330\004\010\210\001\320\tA\300\032\3101\340\004\005\330\004\010\210\001\320\t1\260\032\2701\340\004\005\330\004\010\210\001\320\t0\260\n\270!\340\004\005\330\004\010\210\001\320\t-\250Z\260q\340\004\005\330\004\010\210\001\320\t0\260\n\270!\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t-\250Z\260q\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t2\260*\270A\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t-\250Z\260q\340\004\005\330\004\010\210\001\320\t7\260z\300\021\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t2\260*\270A\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t0\260\n\270!\340\004\005\330\004\010\210\001\320\t6\260j\300\001\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t$\240J\250a\340\004\005\330\004\010\210\001\320\t-\250Z\260q\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320\t%\240Z\250q\340\004\005\330\004\010\210\001\320\t.\250j\270\001\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320\t-\250Z\260q\340\004\005\330\004\010\210\001\320\t/\250z\270\021\340\004\005\330\004\010\210\001\320\t0\260\n\270!\340\004\005\330\004\010\210\001\320\t2\260*\270A\340\004\005\330\004\010\210\001\320\t6\260j\300\001\340\004\005\330\004\010\210\001\320\t=\270Z\300q\340\004\005\330\004\010\210\001\320\t0\260\n\270!\340\004\005\330\004\010\210""\001\320\t.\250j\270\001\340\004\005\330\004\010\210\001\320\t2\260*\270A\340\004\005\330\004\010\210\001\320\t2\260*\270A\340\004\005\330\004\010\210\001\320\t.\250j\270\001\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t.\250j\270\001\340\004\005\330\004\010\210\001\320\t5\260Z\270q\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320\t+\250:\260Q\340\004\005\330\004\010\210\001\320\t.\250j\270\001\340\004\005\330\004\010\210\001\320\t4\260J\270a\340\004\005\330\004\010\210\001\320\t0\260\n\270!\340\004\005\330\004\010\210\001\320\t3\260:\270Q\340\004\005\330\004\010\210\001\320\t4\260J\270a\340\004\005\330\004\010\210\001\320\t;\270:\300Q\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t4\260J\270a\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t#\240:\250Q\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320\t1\260\032\2701\340\004\005\330\004\010\210\001\320\t$\240J\250a\340\004\005\330\004\010\210\001\320\t!\240\032\2501\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320\t'\240z\260\021\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320\t'\240z\260\021\340\004\005\330\004\010\210\001\320\t+\250:\260Q\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t'\240z\260\021\340\004\005\330\004\010\210\001\320\t'\240z\260\021\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320\t+\250:\260Q\340\004\005\330\004\010\210\001\320\t0\260\n\270!\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t0\260\n\270!\340\004\005\330""\004\010\210\001\320\t3\260:\270Q\340\004\005\330\004\010\210\001\320\t3\260:\270Q\340\004\005\330\004\010\210\001\320\t/\250z\270\021\340\004\005\330\004\010\210\001\320\t9\270\032\3001\340\004\005\330\004\010\210\001\320\t9\270\032\3001\340\004\005\330\004\010\210\001\320\t+\250:\260Q\340\004\005\330\004\010\210\001\320\t-\250Z\260q\340\004\005\330\004\010\210\001\320\t4\260J\270a\340\004\005\330\004\010\210\001\320\t.\250j\270\001\340\004\005\330\004\010\210\001\320\t7\260z\300\021\340\004\005\330\004\010\210\001\320\t.\250j\270\001\340\004\005\330\004\010\210\001\320\t.\250j\270\001\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t%\240Z\250q\340\004\005\330\004\010\210\001\320\t$\240J\250a\340\004\005\330\004\010\210\001\320\t4\260J\270a\340\004\005\330\004\010\210\001\320\t(\250\n\260!\340\004\005\330\004\010\210\001\320\t/\250z\270\021\340\004\005\330\004\010\210\001\320\t/\250z\270\021\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t'\240z\260\021\340\004\005\330\004\010\210\001\320\t.\250j\270\001\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t1\260\032\2701\340\004\005\330\004\010\210\001\320\t(\250\n\260!\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320\t(\250\n\260!\340\004\005\330\004\010\210\001\320\t(\250\n\260!\340\004\005\330\004\010\210\001\320\t3\260:\270Q\340\004\005\330\004\010\210\001\320\t+\250:\260Q\340\004\005\330\004\010\210\001\320\t1\260\032\2701\340\004\005\330\004\010\210\001\320\t(\250\n\260!\340\004\005\330\004\010\210\001\320\t2\260*\270A\340\004\005\330\004\010\210\001\320\t+\250:\260Q\340\004\005\330\004\010\210\001\320\t3\260:\270Q\340\004\005\330\004\010\210\001\320\t3\260:\270Q\340\004\005\330\004\010\210\001\320\t0\260\n\270!\340\004\005\330\004\010\210\001\320\t3\260:\270Q\340\004\005\330\004\010\210\001\320\t,\250J\260a\340""\004\005\330\004\010\210\001\320\t/\250z\270\021\340\004\005\330\004\010\210\001\320\t1\260\032\2701\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t1\260\032\2701\340\004\005\330\004\010\210\001\320\t:\270*\300A\340\004\005\330\004\010\210\001\320\t.\250j\270\001\340\004\005\330\004\010\210\001\320\t5\260Z\270q\340\004\005\330\004\010\210\001\320\t5\260Z\270q\340\004\005\330\004\010\210\001\320\t3\260:\270Q\340\004\005\330\004\010\210\001\320\t>\270j\310\001\340\004\005\330\004\010\210\001\320\t8\270\n\300!\340\004\005\330\004\010\210\001\320\t8\270\n\300!\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320\t0\260\n\270!\340\004\005\330\004\010\210\001\320\t.\250j\270\001\340\004\005\330\004\010\210\001\320\t0\260\n\270!\340\004\005\330\004\010\210\001\320\t7\260z\300\021\340\004\005\330\004\010\210\001\320\t0\260\n\270!\340\004\005\330\004\010\210\001\320\t#\240:\250Q\340\004\005\330\004\010\210\001\320\t#\240:\250Q\340\004\005\330\004\010\210\001\320\t-\250Z\260q\340\004\005\330\004\010\210\001\320\t:\270*\300A\340\004\005\330\004\010\210\001\320\t4\260J\270a\340\004\005\330\004\010\210\001\320\t:\270*\300A\340\004\005\330\004\010\210\001\320\t2\260*\270A\340\004\005\330\004\010\210\001\320\t2\260*\270A\340\004\005\330\004\010\210\001\320\t3\260:\270Q\340\004\005\330\004\010\210\001\320\t4\260J\270a\340\004\005\330\004\010\210\001\320\t2\260*\270A\340\004\005\330\004\010\210\001\320\t+\250:\260Q\340\004\005\330\004\010\210\001\320\t1\260\032\2701\340\004\005\330\004\010\210\001\320\t%\240Z\250q\340\004\005\330\004\010\210\001\320\t%\240Z\250q\340\004\005\330\004\010\210\001\320\t5\260Z\270q\340\004\005\330\004\010\210\001\320\t>\270j\310\001\340\004\005\330\004\010\210\001\320\t:\270*\300A\340\004""\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t9\270\032\3001\340\004\005\330\004\010\210\001\320\t'\240z\260\021\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t-\250Z\260q\340\004\005\330\004\010\210\001\320\t'\240z\260\021\340\004\005\330\004\010\210\001\320\t>\270j\310\001\340\004\005\330\004\010\210\001\320\tC\300:\310Q\340\004\005\330\004\010\210\001\320\tD\300J\310a\340\004\005\330\004\010\210\001\320\t5\260Z\270q\340\004\005\330\004\010\210\001\320\tB\300*\310A\340\004\005\330\004\010\210\001\320\t+\250:\260Q\340\004\005\330\004\010\210\001\320\t3\260:\270Q\340\004\005\330\004\010\210\001\320\t6\260j\300\001\340\004\005\330\004\010\210\001\320\t.\250j\270\001\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t+\250:\260Q\340\004\005\330\004\010\210\001\320\t/\250z\270\021\340\004\005\330\004\010\210\001\320\t/\250z\270\021\340\004\005\330\004\010\210\001\320\t4\260J\270a\340\004\005\330\004\010\210\001\320\t=\270Z\300q\340\004\005\330\004\010\210\001\320\t!\240\032\2501\340\004\005\330\004\010\210\001\320\t$\240J\250a\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t/\250z\270\021\340\004\005\330\004\010\210\001\320\t+\250:\260Q\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\tE\300Z\310q\340\004\005\330\004\010\210\001\320\t>\270j\310\001\340\004\005\330\004\010\210\001\320\tA\300\032\3101\340\004\005\330\004\010\210\001\320\t1\260\032\2701\340\004\005\330\004\010\210\001\320\t,\250J\260a\340\004\005\330\004\010\210\001\320\t*\250*\260A\340\004\005\330\004\010\210\001\320\t/\250z\270\021\340\004\005\330\004\010\210\001\320\t/\250z\270\021\340\004\005\330\004\010\210\001\320\t!\240\032\2501\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320\t)\250\032\2601\340\004\005\330\004\010\210\001\320\t(\250\n\260!\340\004\005\330\004\010\210\001\320\t*""\250*\260A\340\004\005\330\004\010\210\001\320\t9\270\032\3001\340\004\005\330\004\010\210\001\320\tA\300\032\3101\340\004\020\220\001\330\004\013\2101";
    PyObject *data = NULL;
    CYTHON_UNUSED_VAR(__Pyx_DecompressString);
    #endif
    PyObject **stringtab = __pyx_mstate->__pyx_string_tab;
    Py_ssize_t pos = 0;
    for (int i = 0; i < 733; i++) {
      Py_ssize_t bytes_length = index[i].length;
      PyObject *string = PyUnicode_DecodeUTF8(bytes + pos, bytes_length, NULL);
      if (likely(string) && i >= 357) PyUnicode_InternInPlace(&string);
      if (unlikely(!string)) {
        Py_XDECREF(data);
        __PYX_ERR(0, 1, __pyx_L1_error)
      }
      stringtab[i] = string;
      pos += bytes_length;
    }
    for (int i = 733; i < 736; i++) {
      Py_ssize_t bytes_length = index[i].length;
      PyObject *string = PyBytes_FromStringAndSize(bytes + pos, bytes_length);
      stringtab[i] = string;
      pos += bytes_length;
      if (unlikely(!string)) {
        Py_XDECREF(data);
        __PYX_ERR(0, 1, __pyx_L1_error)
      }
    }
    Py_XDECREF(data);
    for (Py_ssize_t i = 0; i < 736; i++) {
      if (unlikely(PyObject_Hash(stringtab[i]) == -1)) {
        __PYX_ERR(0, 1, __pyx_L1_error)
      }
    }
    #if CYTHON_IMMORTAL_CONSTANTS
    {
      PyObject **table = stringtab + 733;
      for (Py_ssize_t i=0; i<3; ++i) {
        #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
        Py_SET_REFCNT(table[i], _Py_IMMORTAL_REFCNT_LOCAL);
        #else
        Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT);
        #endif
      }
    }
    #endif
  }
  return 0;
  __pyx_L1_error:;
  return -1;
}
/* #### Code section: init_codeobjects ### */
typedef struct {
    unsigned int argcount : 1;
    unsigned int num_posonly_args : 1;
    unsigned int num_kwonly_args : 1;
    unsigned int nlocals : 1;
    unsigned int flags : 10;
    unsigned int first_line : 12;
} __Pyx_PyCode_New_function_description;
/* NewCodeObj.proto */
static PyObject* __Pyx_PyCode_New(
        const __Pyx_PyCode_New_function_description descr,
        PyObject * const *varnames,
        PyObject *filename,
        PyObject *funcname,
        PyObject *line_table,
        PyObject *tuple_dedup_map
);


static int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate) {
  PyObject* tuple_dedup_map = PyDict_New();
  if (unlikely(!tuple_dedup_map)) return -1;
  {
    const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 0, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2869};
    PyObject* const varnames[] = {0};
    __pyx_mstate_global->__pyx_codeobj_tab[0] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_cuda_bindings__internal__nvml_py, __pyx_mstate->__pyx_n_u_inspect_function_pointers, __pyx_mstate->__pyx_kp_b_iso88591_z_q_q_Q_Ja_A_Zq_Q_1_z_2_A_1_Ja, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[0])) goto bad;
  }
  {
    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3922};
    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_name};
    __pyx_mstate_global->__pyx_codeobj_tab[1] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_cuda_bindings__internal__nvml_py, __pyx_mstate->__pyx_n_u_inspect_function_pointer, __pyx_mstate->__pyx_kp_b_iso88591_z_A_a_9AQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[1])) goto bad;
  }
  Py_DECREF(tuple_dedup_map);
  return 0;
  bad:
  Py_DECREF(tuple_dedup_map);
  return -1;
}
/* #### Code section: init_globals ### */

static int __Pyx_InitGlobals(void) {
  /* PythonCompatibility.init */
  if (likely(__Pyx_init_co_variables() == 0)); else
  
  if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error)

  /* CommonTypesMetaclass.init */
  if (likely(__pyx_CommonTypesMetaclass_init(__pyx_m) == 0)); else
  
  if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error)

  /* CachedMethodType.init */
  #if CYTHON_COMPILING_IN_LIMITED_API
  {
      PyObject *typesModule=NULL;
      typesModule = PyImport_ImportModule("types");
      if (typesModule) {
          __pyx_mstate_global->__Pyx_CachedMethodType = PyObject_GetAttrString(typesModule, "MethodType");
          Py_DECREF(typesModule);
      }
  } // error handling follows
  #endif
  
  if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error)

  /* CythonFunctionShared.init */
  if (likely(__pyx_CyFunction_init(__pyx_m) == 0)); else
  
  if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error)

  return 0;
  __pyx_L1_error:;
  return -1;
}
/* #### Code section: cleanup_globals ### */
/* #### Code section: cleanup_module ### */
/* #### Code section: main_method ### */
/* #### Code section: utility_code_pragmas ### */
#ifdef _MSC_VER
#pragma warning( push )
/* Warning 4127: conditional expression is constant
 * Cython uses constant conditional expressions to allow in inline functions to be optimized at
 * compile-time, so this warning is not useful
 */
#pragma warning( disable : 4127 )
#endif



/* #### Code section: utility_code_def ### */

/* --- Runtime support code --- */
/* Refnanny */
#if CYTHON_REFNANNY
static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
    PyObject *m = NULL, *p = NULL;
    void *r = NULL;
    m = PyImport_ImportModule(modname);
    if (!m) goto end;
    p = PyObject_GetAttrString(m, "RefNannyAPI");
    if (!p) goto end;
    r = PyLong_AsVoidPtr(p);
end:
    Py_XDECREF(p);
    Py_XDECREF(m);
    return (__Pyx_RefNannyAPIStruct *)r;
}
#endif

/* PyErrExceptionMatches (used by PyObjectGetAttrStrNoError) */
#if CYTHON_FAST_THREAD_STATE
static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
    Py_ssize_t i, n;
    n = PyTuple_GET_SIZE(tuple);
    for (i=0; i<n; i++) {
        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
    }
    for (i=0; i<n; i++) {
        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
    }
    return 0;
}
static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
    int result;
    PyObject *exc_type;
#if PY_VERSION_HEX >= 0x030C00A6
    PyObject *current_exception = tstate->current_exception;
    if (unlikely(!current_exception)) return 0;
    exc_type = (PyObject*) Py_TYPE(current_exception);
    if (exc_type == err) return 1;
#else
    exc_type = tstate->curexc_type;
    if (exc_type == err) return 1;
    if (unlikely(!exc_type)) return 0;
#endif
    #if CYTHON_AVOID_BORROWED_REFS
    Py_INCREF(exc_type);
    #endif
    if (unlikely(PyTuple_Check(err))) {
        result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
    } else {
        result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
    }
    #if CYTHON_AVOID_BORROWED_REFS
    Py_DECREF(exc_type);
    #endif
    return result;
}
#endif

/* PyErrFetchRestore (used by PyObjectGetAttrStrNoError) */
#if CYTHON_FAST_THREAD_STATE
static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
#if PY_VERSION_HEX >= 0x030C00A6
    PyObject *tmp_value;
    assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value)));
    if (value) {
        #if CYTHON_COMPILING_IN_CPYTHON
        if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb))
        #endif
            PyException_SetTraceback(value, tb);
    }
    tmp_value = tstate->current_exception;
    tstate->current_exception = value;
    Py_XDECREF(tmp_value);
    Py_XDECREF(type);
    Py_XDECREF(tb);
#else
    PyObject *tmp_type, *tmp_value, *tmp_tb;
    tmp_type = tstate->curexc_type;
    tmp_value = tstate->curexc_value;
    tmp_tb = tstate->curexc_traceback;
    tstate->curexc_type = type;
    tstate->curexc_value = value;
    tstate->curexc_traceback = tb;
    Py_XDECREF(tmp_type);
    Py_XDECREF(tmp_value);
    Py_XDECREF(tmp_tb);
#endif
}
static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
#if PY_VERSION_HEX >= 0x030C00A6
    PyObject* exc_value;
    exc_value = tstate->current_exception;
    tstate->current_exception = 0;
    *value = exc_value;
    *type = NULL;
    *tb = NULL;
    if (exc_value) {
        *type = (PyObject*) Py_TYPE(exc_value);
        Py_INCREF(*type);
        #if CYTHON_COMPILING_IN_CPYTHON
        *tb = ((PyBaseExceptionObject*) exc_value)->traceback;
        Py_XINCREF(*tb);
        #else
        *tb = PyException_GetTraceback(exc_value);
        #endif
    }
#else
    *type = tstate->curexc_type;
    *value = tstate->curexc_value;
    *tb = tstate->curexc_traceback;
    tstate->curexc_type = 0;
    tstate->curexc_value = 0;
    tstate->curexc_traceback = 0;
#endif
}
#endif

/* PyObjectGetAttrStr (used by PyObjectGetAttrStrNoError) */
#if CYTHON_USE_TYPE_SLOTS
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
    PyTypeObject* tp = Py_TYPE(obj);
    if (likely(tp->tp_getattro))
        return tp->tp_getattro(obj, attr_name);
    return PyObject_GetAttr(obj, attr_name);
}
#endif

/* PyObjectGetAttrStrNoError (used by GetBuiltinName) */
#if __PYX_LIMITED_VERSION_HEX < 0x030d0000
static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
        __Pyx_PyErr_Clear();
}
#endif
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
    PyObject *result;
#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
    (void) PyObject_GetOptionalAttr(obj, attr_name, &result);
    return result;
#else
#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS
    PyTypeObject* tp = Py_TYPE(obj);
    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
    }
#endif
    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
    if (unlikely(!result)) {
        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
    }
    return result;
#endif
}

/* GetBuiltinName (used by GetModuleGlobalName) */
static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
    PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_mstate_global->__pyx_b, name);
    if (unlikely(!result) && !PyErr_Occurred()) {
        PyErr_Format(PyExc_NameError,
            "name '%U' is not defined", name);
    }
    return result;
}

/* PyDictVersioning (used by GetModuleGlobalName) */
#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) {
    PyObject *dict = Py_TYPE(obj)->tp_dict;
    return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0;
}
static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) {
    PyObject **dictptr = NULL;
    Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset;
    if (offset) {
#if CYTHON_COMPILING_IN_CPYTHON
        dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj);
#else
        dictptr = _PyObject_GetDictPtr(obj);
#endif
    }
    return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0;
}
static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) {
    PyObject *dict = Py_TYPE(obj)->tp_dict;
    if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict)))
        return 0;
    return obj_dict_version == __Pyx_get_object_dict_version(obj);
}
#endif

/* GetModuleGlobalName */
#if CYTHON_USE_DICT_VERSIONS
static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value)
#else
static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
#endif
{
    PyObject *result;
#if CYTHON_COMPILING_IN_LIMITED_API
    if (unlikely(!__pyx_m)) {
        if (!PyErr_Occurred())
            PyErr_SetNone(PyExc_NameError);
        return NULL;
    }
    result = PyObject_GetAttr(__pyx_m, name);
    if (likely(result)) {
        return result;
    }
    PyErr_Clear();
#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
    if (unlikely(__Pyx_PyDict_GetItemRef(__pyx_mstate_global->__pyx_d, name, &result) == -1)) PyErr_Clear();
    __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version)
    if (likely(result)) {
        return result;
    }
#else
    result = _PyDict_GetItem_KnownHash(__pyx_mstate_global->__pyx_d, name, ((PyASCIIObject *) name)->hash);
    __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version)
    if (likely(result)) {
        return __Pyx_NewRef(result);
    }
    PyErr_Clear();
#endif
    return __Pyx_GetBuiltinName(name);
}

/* decode_c_string */
static CYTHON_INLINE PyObject* __Pyx_decode_c_string(
         const char* cstring, Py_ssize_t start, Py_ssize_t stop,
         const char* encoding, const char* errors,
         PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) {
    Py_ssize_t length;
    if (unlikely((start < 0) | (stop < 0))) {
        size_t slen = strlen(cstring);
        if (unlikely(slen > (size_t) PY_SSIZE_T_MAX)) {
            PyErr_SetString(PyExc_OverflowError,
                            "c-string too long to convert to Python");
            return NULL;
        }
        length = (Py_ssize_t) slen;
        if (start < 0) {
            start += length;
            if (start < 0)
                start = 0;
        }
        if (stop < 0)
            stop += length;
    }
    if (unlikely(stop <= start))
        return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_unicode);
    length = stop - start;
    cstring += start;
    if (decode_func) {
        return decode_func(cstring, length, errors);
    } else {
        return PyUnicode_Decode(cstring, length, encoding, errors);
    }
}

/* JoinPyUnicode */
static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength,
                                      Py_UCS4 max_char) {
#if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    PyObject *result_uval;
    int result_ukind, kind_shift;
    Py_ssize_t i, char_pos;
    void *result_udata;
    if (max_char > 1114111) max_char = 1114111;
    result_uval = PyUnicode_New(result_ulength, max_char);
    if (unlikely(!result_uval)) return NULL;
    result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND;
    kind_shift = (result_ukind == PyUnicode_4BYTE_KIND) ? 2 : result_ukind - 1;
    result_udata = PyUnicode_DATA(result_uval);
    assert(kind_shift == 2 || kind_shift == 1 || kind_shift == 0);
    if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - result_ulength < 0))
        goto overflow;
    char_pos = 0;
    for (i=0; i < value_count; i++) {
        int ukind;
        Py_ssize_t ulength;
        void *udata;
        PyObject *uval = values[i];
        #if !CYTHON_COMPILING_IN_LIMITED_API
        if (__Pyx_PyUnicode_READY(uval) == (-1))
            goto bad;
        #endif
        ulength = __Pyx_PyUnicode_GET_LENGTH(uval);
        #if !CYTHON_ASSUME_SAFE_SIZE
        if (unlikely(ulength < 0)) goto bad;
        #endif
        if (unlikely(!ulength))
            continue;
        if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - ulength < char_pos))
            goto overflow;
        ukind = __Pyx_PyUnicode_KIND(uval);
        udata = __Pyx_PyUnicode_DATA(uval);
        if (ukind == result_ukind) {
            memcpy((char *)result_udata + (char_pos << kind_shift), udata, (size_t) (ulength << kind_shift));
        } else {
            #if PY_VERSION_HEX >= 0x030d0000
            if (unlikely(PyUnicode_CopyCharacters(result_uval, char_pos, uval, 0, ulength) < 0)) goto bad;
            #elif CYTHON_COMPILING_IN_CPYTHON || defined(_PyUnicode_FastCopyCharacters)
            _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength);
            #else
            Py_ssize_t j;
            for (j=0; j < ulength; j++) {
                Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j);
                __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar);
            }
            #endif
        }
        char_pos += ulength;
    }
    return result_uval;
overflow:
    PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string");
bad:
    Py_DECREF(result_uval);
    return NULL;
#else
    Py_ssize_t i;
    PyObject *result = NULL;
    PyObject *value_tuple = PyTuple_New(value_count);
    if (unlikely(!value_tuple)) return NULL;
    CYTHON_UNUSED_VAR(max_char);
    CYTHON_UNUSED_VAR(result_ulength);
    for (i=0; i<value_count; i++) {
        if (__Pyx_PyTuple_SET_ITEM(value_tuple, i, values[i]) != (0)) goto bad;
        Py_INCREF(values[i]);
    }
    result = PyUnicode_Join(__pyx_mstate_global->__pyx_empty_unicode, value_tuple);
bad:
    Py_DECREF(value_tuple);
    return result;
#endif
}

/* PyObjectCall (used by PyObjectFastCall) */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
    PyObject *result;
    ternaryfunc call = Py_TYPE(func)->tp_call;
    if (unlikely(!call))
        return PyObject_Call(func, arg, kw);
    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
        return NULL;
    result = (*call)(func, arg, kw);
    Py_LeaveRecursiveCall();
    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
        PyErr_SetString(
            PyExc_SystemError,
            "NULL result without error in PyObject_Call");
    }
    return result;
}
#endif

/* PyObjectCallMethO (used by PyObjectFastCall) */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
    PyObject *self, *result;
    PyCFunction cfunc;
    cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func);
    self = __Pyx_CyOrPyCFunction_GET_SELF(func);
    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
        return NULL;
    result = cfunc(self, arg);
    Py_LeaveRecursiveCall();
    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
        PyErr_SetString(
            PyExc_SystemError,
            "NULL result without error in PyObject_Call");
    }
    return result;
}
#endif

/* PyObjectFastCall */
#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API
static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs) {
    PyObject *argstuple;
    PyObject *result = 0;
    size_t i;
    argstuple = PyTuple_New((Py_ssize_t)nargs);
    if (unlikely(!argstuple)) return NULL;
    for (i = 0; i < nargs; i++) {
        Py_INCREF(args[i]);
        if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) != (0)) goto bad;
    }
    result = __Pyx_PyObject_Call(func, argstuple, kwargs);
  bad:
    Py_DECREF(argstuple);
    return result;
}
#endif
#if CYTHON_VECTORCALL && !CYTHON_COMPILING_IN_LIMITED_API
  #if PY_VERSION_HEX < 0x03090000
    #define __Pyx_PyVectorcall_Function(callable) _PyVectorcall_Function(callable)
  #elif CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE vectorcallfunc __Pyx_PyVectorcall_Function(PyObject *callable) {
    PyTypeObject *tp = Py_TYPE(callable);
    #if defined(__Pyx_CyFunction_USED)
    if (__Pyx_CyFunction_CheckExact(callable)) {
        return __Pyx_CyFunction_func_vectorcall(callable);
    }
    #endif
    if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) {
        return NULL;
    }
    assert(PyCallable_Check(callable));
    Py_ssize_t offset = tp->tp_vectorcall_offset;
    assert(offset > 0);
    vectorcallfunc ptr;
    memcpy(&ptr, (char *) callable + offset, sizeof(ptr));
    return ptr;
}
  #else
    #define __Pyx_PyVectorcall_Function(callable) PyVectorcall_Function(callable)
  #endif
#endif
static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject *const *args, size_t _nargs, PyObject *kwargs) {
    Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs);
#if CYTHON_COMPILING_IN_CPYTHON
    if (nargs == 0 && kwargs == NULL) {
        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS))
            return __Pyx_PyObject_CallMethO(func, NULL);
    }
    else if (nargs == 1 && kwargs == NULL) {
        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O))
            return __Pyx_PyObject_CallMethO(func, args[0]);
    }
#endif
    if (kwargs == NULL) {
        #if CYTHON_VECTORCALL
          #if CYTHON_COMPILING_IN_LIMITED_API
            return PyObject_Vectorcall(func, args, _nargs, NULL);
          #else
            vectorcallfunc f = __Pyx_PyVectorcall_Function(func);
            if (f) {
                return f(func, args, _nargs, NULL);
            }
          #endif
        #endif
    }
    if (nargs == 0) {
        return __Pyx_PyObject_Call(func, __pyx_mstate_global->__pyx_empty_tuple, kwargs);
    }
    #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API
    return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs);
    #else
    return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs);
    #endif
}

/* RaiseException */
static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
    PyObject* owned_instance = NULL;
    if (tb == Py_None) {
        tb = 0;
    } else if (tb && !PyTraceBack_Check(tb)) {
        PyErr_SetString(PyExc_TypeError,
            "raise: arg 3 must be a traceback or None");
        goto bad;
    }
    if (value == Py_None)
        value = 0;
    if (PyExceptionInstance_Check(type)) {
        if (value) {
            PyErr_SetString(PyExc_TypeError,
                "instance exception may not have a separate value");
            goto bad;
        }
        value = type;
        type = (PyObject*) Py_TYPE(value);
    } else if (PyExceptionClass_Check(type)) {
        PyObject *instance_class = NULL;
        if (value && PyExceptionInstance_Check(value)) {
            instance_class = (PyObject*) Py_TYPE(value);
            if (instance_class != type) {
                int is_subclass = PyObject_IsSubclass(instance_class, type);
                if (!is_subclass) {
                    instance_class = NULL;
                } else if (unlikely(is_subclass == -1)) {
                    goto bad;
                } else {
                    type = instance_class;
                }
            }
        }
        if (!instance_class) {
            PyObject *args;
            if (!value)
                args = PyTuple_New(0);
            else if (PyTuple_Check(value)) {
                Py_INCREF(value);
                args = value;
            } else
                args = PyTuple_Pack(1, value);
            if (!args)
                goto bad;
            owned_instance = PyObject_Call(type, args, NULL);
            Py_DECREF(args);
            if (!owned_instance)
                goto bad;
            value = owned_instance;
            if (!PyExceptionInstance_Check(value)) {
                PyErr_Format(PyExc_TypeError,
                             "calling %R should have returned an instance of "
                             "BaseException, not %R",
                             type, Py_TYPE(value));
                goto bad;
            }
        }
    } else {
        PyErr_SetString(PyExc_TypeError,
            "raise: exception class must be a subclass of BaseException");
        goto bad;
    }
    if (cause) {
        PyObject *fixed_cause;
        if (cause == Py_None) {
            fixed_cause = NULL;
        } else if (PyExceptionClass_Check(cause)) {
            fixed_cause = PyObject_CallObject(cause, NULL);
            if (fixed_cause == NULL)
                goto bad;
        } else if (PyExceptionInstance_Check(cause)) {
            fixed_cause = cause;
            Py_INCREF(fixed_cause);
        } else {
            PyErr_SetString(PyExc_TypeError,
                            "exception causes must derive from "
                            "BaseException");
            goto bad;
        }
        PyException_SetCause(value, fixed_cause);
    }
    PyErr_SetObject(type, value);
    if (tb) {
#if PY_VERSION_HEX >= 0x030C00A6
        PyException_SetTraceback(value, tb);
#elif CYTHON_FAST_THREAD_STATE
        PyThreadState *tstate = __Pyx_PyThreadState_Current;
        PyObject* tmp_tb = tstate->curexc_traceback;
        if (tb != tmp_tb) {
            Py_INCREF(tb);
            tstate->curexc_traceback = tb;
            Py_XDECREF(tmp_tb);
        }
#else
        PyObject *tmp_type, *tmp_value, *tmp_tb;
        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
        Py_INCREF(tb);
        PyErr_Restore(tmp_type, tmp_value, tb);
        Py_XDECREF(tmp_tb);
#endif
    }
bad:
    Py_XDECREF(owned_instance);
    return;
}

/* CIntToDigits (used by CIntToPyUnicode) */
static const char DIGIT_PAIRS_10[2*10*10+1] = {
    "00010203040506070809"
    "10111213141516171819"
    "20212223242526272829"
    "30313233343536373839"
    "40414243444546474849"
    "50515253545556575859"
    "60616263646566676869"
    "70717273747576777879"
    "80818283848586878889"
    "90919293949596979899"
};
static const char DIGIT_PAIRS_8[2*8*8+1] = {
    "0001020304050607"
    "1011121314151617"
    "2021222324252627"
    "3031323334353637"
    "4041424344454647"
    "5051525354555657"
    "6061626364656667"
    "7071727374757677"
};
static const char DIGITS_HEX[2*16+1] = {
    "0123456789abcdef"
    "0123456789ABCDEF"
};

/* BuildPyUnicode (used by COrdinalToPyUnicode) */
static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, const char* chars, int clength,
                                                int prepend_sign, char padding_char) {
    PyObject *uval;
    Py_ssize_t uoffset = ulength - clength;
#if CYTHON_USE_UNICODE_INTERNALS
    Py_ssize_t i;
    void *udata;
    uval = PyUnicode_New(ulength, 127);
    if (unlikely(!uval)) return NULL;
    udata = PyUnicode_DATA(uval);
    if (uoffset > 0) {
        i = 0;
        if (prepend_sign) {
            __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, 0, '-');
            i++;
        }
        for (; i < uoffset; i++) {
            __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, i, padding_char);
        }
    }
    for (i=0; i < clength; i++) {
        __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, uoffset+i, chars[i]);
    }
#else
    {
        PyObject *sign = NULL, *padding = NULL;
        uval = NULL;
        if (uoffset > 0) {
            prepend_sign = !!prepend_sign;
            if (uoffset > prepend_sign) {
                padding = PyUnicode_FromOrdinal(padding_char);
                if (likely(padding) && uoffset > prepend_sign + 1) {
                    PyObject *tmp = PySequence_Repeat(padding, uoffset - prepend_sign);
                    Py_DECREF(padding);
                    padding = tmp;
                }
                if (unlikely(!padding)) goto done_or_error;
            }
            if (prepend_sign) {
                sign = PyUnicode_FromOrdinal('-');
                if (unlikely(!sign)) goto done_or_error;
            }
        }
        uval = PyUnicode_DecodeASCII(chars, clength, NULL);
        if (likely(uval) && padding) {
            PyObject *tmp = PyUnicode_Concat(padding, uval);
            Py_DECREF(uval);
            uval = tmp;
        }
        if (likely(uval) && sign) {
            PyObject *tmp = PyUnicode_Concat(sign, uval);
            Py_DECREF(uval);
            uval = tmp;
        }
done_or_error:
        Py_XDECREF(padding);
        Py_XDECREF(sign);
    }
#endif
    return uval;
}

/* COrdinalToPyUnicode (used by CIntToPyUnicode) */
static CYTHON_INLINE int __Pyx_CheckUnicodeValue(int value) {
    return value <= 1114111;
}
static PyObject* __Pyx_PyUnicode_FromOrdinal_Padded(int value, Py_ssize_t ulength, char padding_char) {
    Py_ssize_t padding_length = ulength - 1;
    if (likely((padding_length <= 250) && (value < 0xD800 || value > 0xDFFF))) {
        char chars[256];
        if (value <= 255) {
            memset(chars, padding_char, (size_t) padding_length);
            chars[ulength-1] = (char) value;
            return PyUnicode_DecodeLatin1(chars, ulength, NULL);
        }
        char *cpos = chars + sizeof(chars);
        if (value < 0x800) {
            *--cpos = (char) (0x80 | (value & 0x3f));
            value >>= 6;
            *--cpos = (char) (0xc0 | (value & 0x1f));
        } else if (value < 0x10000) {
            *--cpos = (char) (0x80 | (value & 0x3f));
            value >>= 6;
            *--cpos = (char) (0x80 | (value & 0x3f));
            value >>= 6;
            *--cpos = (char) (0xe0 | (value & 0x0f));
        } else {
            *--cpos = (char) (0x80 | (value & 0x3f));
            value >>= 6;
            *--cpos = (char) (0x80 | (value & 0x3f));
            value >>= 6;
            *--cpos = (char) (0x80 | (value & 0x3f));
            value >>= 6;
            *--cpos = (char) (0xf0 | (value & 0x07));
        }
        cpos -= padding_length;
        memset(cpos, padding_char, (size_t) padding_length);
        return PyUnicode_DecodeUTF8(cpos, chars + sizeof(chars) - cpos, NULL);
    }
    if (value <= 127 && CYTHON_USE_UNICODE_INTERNALS) {
        const char chars[1] = {(char) value};
        return __Pyx_PyUnicode_BuildFromAscii(ulength, chars, 1, 0, padding_char);
    }
    {
        PyObject *uchar, *padding_uchar, *padding, *result;
        padding_uchar = PyUnicode_FromOrdinal(padding_char);
        if (unlikely(!padding_uchar)) return NULL;
        padding = PySequence_Repeat(padding_uchar, padding_length);
        Py_DECREF(padding_uchar);
        if (unlikely(!padding)) return NULL;
        uchar = PyUnicode_FromOrdinal(value);
        if (unlikely(!uchar)) {
            Py_DECREF(padding);
            return NULL;
        }
        result = PyUnicode_Concat(padding, uchar);
        Py_DECREF(padding);
        Py_DECREF(uchar);
        return result;
    }
}

/* CIntToPyUnicode */
static CYTHON_INLINE PyObject* __Pyx_uchar___Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const int neg_one = (int) -1, const_zero = (int) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (unlikely(!(is_unsigned || value == 0 || value > 0) ||
                    !(sizeof(value) <= 2 || value & ~ (int) 0x01fffff || __Pyx_CheckUnicodeValue((int) value)))) {
        PyErr_SetString(PyExc_OverflowError, "%c arg not in range(0x110000)");
        return NULL;
    }
    if (width <= 1) {
        return PyUnicode_FromOrdinal((int) value);
    }
    return __Pyx_PyUnicode_FromOrdinal_Padded((int) value, width, padding_char);
}
static CYTHON_INLINE PyObject* __Pyx____Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char) {
    char digits[sizeof(int)*3+2];
    char *dpos, *end = digits + sizeof(int)*3+2;
    const char *hex_digits = DIGITS_HEX;
    Py_ssize_t length, ulength;
    int prepend_sign, last_one_off;
    int remaining;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const int neg_one = (int) -1, const_zero = (int) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (format_char == 'X') {
        hex_digits += 16;
        format_char = 'x';
    }
    remaining = value;
    last_one_off = 0;
    dpos = end;
    do {
        int digit_pos;
        switch (format_char) {
        case 'o':
            digit_pos = abs((int)(remaining % (8*8)));
            remaining = (int) (remaining / (8*8));
            dpos -= 2;
            memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2);
            last_one_off = (digit_pos < 8);
            break;
        case 'd':
            digit_pos = abs((int)(remaining % (10*10)));
            remaining = (int) (remaining / (10*10));
            dpos -= 2;
            memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2);
            last_one_off = (digit_pos < 10);
            break;
        case 'x':
            *(--dpos) = hex_digits[abs((int)(remaining % 16))];
            remaining = (int) (remaining / 16);
            break;
        default:
            assert(0);
            break;
        }
    } while (unlikely(remaining != 0));
    assert(!last_one_off || *dpos == '0');
    dpos += last_one_off;
    length = end - dpos;
    ulength = length;
    prepend_sign = 0;
    if (!is_unsigned && value <= neg_one) {
        if (padding_char == ' ' || width <= length + 1) {
            *(--dpos) = '-';
            ++length;
        } else {
            prepend_sign = 1;
        }
        ++ulength;
    }
    if (width > ulength) {
        ulength = width;
    }
    if (ulength == 1) {
        return PyUnicode_FromOrdinal(*dpos);
    }
    return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char);
}

/* PyObjectLookupSpecial */
#if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
static CYTHON_INLINE PyObject* __Pyx__PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name, int with_error) {
    PyObject *res;
    PyTypeObject *tp = Py_TYPE(obj);
    res = _PyType_Lookup(tp, attr_name);
    if (likely(res)) {
        descrgetfunc f = Py_TYPE(res)->tp_descr_get;
        if (!f) {
            Py_INCREF(res);
        } else {
            res = f(res, obj, (PyObject *)tp);
        }
    } else if (with_error) {
        PyErr_SetObject(PyExc_AttributeError, attr_name);
    }
    return res;
}
#endif

/* GetTopmostException (used by SaveResetException) */
#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE
static _PyErr_StackItem *
__Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
{
    _PyErr_StackItem *exc_info = tstate->exc_info;
    while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) &&
           exc_info->previous_item != NULL)
    {
        exc_info = exc_info->previous_item;
    }
    return exc_info;
}
#endif

/* SaveResetException */
#if CYTHON_FAST_THREAD_STATE
static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
    PyObject *exc_value = exc_info->exc_value;
    if (exc_value == NULL || exc_value == Py_None) {
        *value = NULL;
        *type = NULL;
        *tb = NULL;
    } else {
        *value = exc_value;
        Py_INCREF(*value);
        *type = (PyObject*) Py_TYPE(exc_value);
        Py_INCREF(*type);
        *tb = PyException_GetTraceback(exc_value);
    }
  #elif CYTHON_USE_EXC_INFO_STACK
    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
    *type = exc_info->exc_type;
    *value = exc_info->exc_value;
    *tb = exc_info->exc_traceback;
    Py_XINCREF(*type);
    Py_XINCREF(*value);
    Py_XINCREF(*tb);
  #else
    *type = tstate->exc_type;
    *value = tstate->exc_value;
    *tb = tstate->exc_traceback;
    Py_XINCREF(*type);
    Py_XINCREF(*value);
    Py_XINCREF(*tb);
  #endif
}
static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
    _PyErr_StackItem *exc_info = tstate->exc_info;
    PyObject *tmp_value = exc_info->exc_value;
    exc_info->exc_value = value;
    Py_XDECREF(tmp_value);
    Py_XDECREF(type);
    Py_XDECREF(tb);
  #else
    PyObject *tmp_type, *tmp_value, *tmp_tb;
    #if CYTHON_USE_EXC_INFO_STACK
    _PyErr_StackItem *exc_info = tstate->exc_info;
    tmp_type = exc_info->exc_type;
    tmp_value = exc_info->exc_value;
    tmp_tb = exc_info->exc_traceback;
    exc_info->exc_type = type;
    exc_info->exc_value = value;
    exc_info->exc_traceback = tb;
    #else
    tmp_type = tstate->exc_type;
    tmp_value = tstate->exc_value;
    tmp_tb = tstate->exc_traceback;
    tstate->exc_type = type;
    tstate->exc_value = value;
    tstate->exc_traceback = tb;
    #endif
    Py_XDECREF(tmp_type);
    Py_XDECREF(tmp_value);
    Py_XDECREF(tmp_tb);
  #endif
}
#endif

/* GetException */
#if CYTHON_FAST_THREAD_STATE
static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb)
#else
static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
#endif
{
    PyObject *local_type = NULL, *local_value, *local_tb = NULL;
#if CYTHON_FAST_THREAD_STATE
    PyObject *tmp_type, *tmp_value, *tmp_tb;
  #if PY_VERSION_HEX >= 0x030C0000
    local_value = tstate->current_exception;
    tstate->current_exception = 0;
  #else
    local_type = tstate->curexc_type;
    local_value = tstate->curexc_value;
    local_tb = tstate->curexc_traceback;
    tstate->curexc_type = 0;
    tstate->curexc_value = 0;
    tstate->curexc_traceback = 0;
  #endif
#elif __PYX_LIMITED_VERSION_HEX > 0x030C0000
    local_value = PyErr_GetRaisedException();
#else
    PyErr_Fetch(&local_type, &local_value, &local_tb);
#endif
#if __PYX_LIMITED_VERSION_HEX > 0x030C0000
    if (likely(local_value)) {
        local_type = (PyObject*) Py_TYPE(local_value);
        Py_INCREF(local_type);
        local_tb = PyException_GetTraceback(local_value);
    }
#else
    PyErr_NormalizeException(&local_type, &local_value, &local_tb);
#if CYTHON_FAST_THREAD_STATE
    if (unlikely(tstate->curexc_type))
#else
    if (unlikely(PyErr_Occurred()))
#endif
        goto bad;
    if (local_tb) {
        if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0))
            goto bad;
    }
#endif // __PYX_LIMITED_VERSION_HEX > 0x030C0000
    Py_XINCREF(local_tb);
    Py_XINCREF(local_type);
    Py_XINCREF(local_value);
    *type = local_type;
    *value = local_value;
    *tb = local_tb;
#if CYTHON_FAST_THREAD_STATE
    #if CYTHON_USE_EXC_INFO_STACK
    {
        _PyErr_StackItem *exc_info = tstate->exc_info;
      #if PY_VERSION_HEX >= 0x030B00a4
        tmp_value = exc_info->exc_value;
        exc_info->exc_value = local_value;
        tmp_type = NULL;
        tmp_tb = NULL;
        Py_XDECREF(local_type);
        Py_XDECREF(local_tb);
      #else
        tmp_type = exc_info->exc_type;
        tmp_value = exc_info->exc_value;
        tmp_tb = exc_info->exc_traceback;
        exc_info->exc_type = local_type;
        exc_info->exc_value = local_value;
        exc_info->exc_traceback = local_tb;
      #endif
    }
    #else
    tmp_type = tstate->exc_type;
    tmp_value = tstate->exc_value;
    tmp_tb = tstate->exc_traceback;
    tstate->exc_type = local_type;
    tstate->exc_value = local_value;
    tstate->exc_traceback = local_tb;
    #endif
    Py_XDECREF(tmp_type);
    Py_XDECREF(tmp_value);
    Py_XDECREF(tmp_tb);
#elif __PYX_LIMITED_VERSION_HEX >= 0x030b0000
    PyErr_SetHandledException(local_value);
    Py_XDECREF(local_value);
    Py_XDECREF(local_type);
    Py_XDECREF(local_tb);
#else
    PyErr_SetExcInfo(local_type, local_value, local_tb);
#endif
    return 0;
#if __PYX_LIMITED_VERSION_HEX <= 0x030C0000
bad:
    *type = 0;
    *value = 0;
    *tb = 0;
    Py_XDECREF(local_type);
    Py_XDECREF(local_value);
    Py_XDECREF(local_tb);
    return -1;
#endif
}

/* TupleAndListFromArray (used by fastcall) */
#if !CYTHON_COMPILING_IN_CPYTHON && CYTHON_METH_FASTCALL
static CYTHON_INLINE PyObject *
__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n)
{
    PyObject *res;
    Py_ssize_t i;
    if (n <= 0) {
        return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple);
    }
    res = PyTuple_New(n);
    if (unlikely(res == NULL)) return NULL;
    for (i = 0; i < n; i++) {
        if (unlikely(__Pyx_PyTuple_SET_ITEM(res, i, src[i]) < (0))) {
            Py_DECREF(res);
            return NULL;
        }
        Py_INCREF(src[i]);
    }
    return res;
}
#elif CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) {
    PyObject *v;
    Py_ssize_t i;
    for (i = 0; i < length; i++) {
        v = dest[i] = src[i];
        Py_INCREF(v);
    }
}
static CYTHON_INLINE PyObject *
__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n)
{
    PyObject *res;
    if (n <= 0) {
        return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple);
    }
    res = PyTuple_New(n);
    if (unlikely(res == NULL)) return NULL;
    __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n);
    return res;
}
static CYTHON_INLINE PyObject *
__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n)
{
    PyObject *res;
    if (n <= 0) {
        return PyList_New(0);
    }
    res = PyList_New(n);
    if (unlikely(res == NULL)) return NULL;
    __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n);
    return res;
}
#endif

/* BytesEquals (used by UnicodeEquals) */
static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL ||\
        !(CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS)
    return PyObject_RichCompareBool(s1, s2, equals);
#else
    if (s1 == s2) {
        return (equals == Py_EQ);
    } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) {
        const char *ps1, *ps2;
        Py_ssize_t length = PyBytes_GET_SIZE(s1);
        if (length != PyBytes_GET_SIZE(s2))
            return (equals == Py_NE);
        ps1 = PyBytes_AS_STRING(s1);
        ps2 = PyBytes_AS_STRING(s2);
        if (ps1[0] != ps2[0]) {
            return (equals == Py_NE);
        } else if (length == 1) {
            return (equals == Py_EQ);
        } else {
            int result;
#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000)
            Py_hash_t hash1, hash2;
            hash1 = ((PyBytesObject*)s1)->ob_shash;
            hash2 = ((PyBytesObject*)s2)->ob_shash;
            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
                return (equals == Py_NE);
            }
#endif
            result = memcmp(ps1, ps2, (size_t)length);
            return (equals == Py_EQ) ? (result == 0) : (result != 0);
        }
    } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) {
        return (equals == Py_NE);
    } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) {
        return (equals == Py_NE);
    } else {
        int result;
        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
        if (!py_result)
            return -1;
        result = __Pyx_PyObject_IsTrue(py_result);
        Py_DECREF(py_result);
        return result;
    }
#endif
}

/* UnicodeEquals (used by fastcall) */
static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) {
#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL
    return PyObject_RichCompareBool(s1, s2, equals);
#else
    int s1_is_unicode, s2_is_unicode;
    if (s1 == s2) {
        goto return_eq;
    }
    s1_is_unicode = PyUnicode_CheckExact(s1);
    s2_is_unicode = PyUnicode_CheckExact(s2);
    if (s1_is_unicode & s2_is_unicode) {
        Py_ssize_t length, length2;
        int kind;
        void *data1, *data2;
        #if !CYTHON_COMPILING_IN_LIMITED_API
        if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0))
            return -1;
        #endif
        length = __Pyx_PyUnicode_GET_LENGTH(s1);
        #if !CYTHON_ASSUME_SAFE_SIZE
        if (unlikely(length < 0)) return -1;
        #endif
        length2 = __Pyx_PyUnicode_GET_LENGTH(s2);
        #if !CYTHON_ASSUME_SAFE_SIZE
        if (unlikely(length2 < 0)) return -1;
        #endif
        if (length != length2) {
            goto return_ne;
        }
#if CYTHON_USE_UNICODE_INTERNALS
        {
            Py_hash_t hash1, hash2;
            hash1 = ((PyASCIIObject*)s1)->hash;
            hash2 = ((PyASCIIObject*)s2)->hash;
            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
                goto return_ne;
            }
        }
#endif
        kind = __Pyx_PyUnicode_KIND(s1);
        if (kind != __Pyx_PyUnicode_KIND(s2)) {
            goto return_ne;
        }
        data1 = __Pyx_PyUnicode_DATA(s1);
        data2 = __Pyx_PyUnicode_DATA(s2);
        if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) {
            goto return_ne;
        } else if (length == 1) {
            goto return_eq;
        } else {
            int result = memcmp(data1, data2, (size_t)(length * kind));
            return (equals == Py_EQ) ? (result == 0) : (result != 0);
        }
    } else if ((s1 == Py_None) & s2_is_unicode) {
        goto return_ne;
    } else if ((s2 == Py_None) & s1_is_unicode) {
        goto return_ne;
    } else {
        int result;
        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
        if (!py_result)
            return -1;
        result = __Pyx_PyObject_IsTrue(py_result);
        Py_DECREF(py_result);
        return result;
    }
return_eq:
    return (equals == Py_EQ);
return_ne:
    return (equals == Py_NE);
#endif
}

/* fastcall */
#if CYTHON_METH_FASTCALL
static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s)
{
    Py_ssize_t i, n = __Pyx_PyTuple_GET_SIZE(kwnames);
    #if !CYTHON_ASSUME_SAFE_SIZE
    if (unlikely(n == -1)) return NULL;
    #endif
    for (i = 0; i < n; i++)
    {
        PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i);
        #if !CYTHON_ASSUME_SAFE_MACROS
        if (unlikely(!namei)) return NULL;
        #endif
        if (s == namei) return kwvalues[i];
    }
    for (i = 0; i < n; i++)
    {
        PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i);
        #if !CYTHON_ASSUME_SAFE_MACROS
        if (unlikely(!namei)) return NULL;
        #endif
        int eq = __Pyx_PyUnicode_Equals(s, namei, Py_EQ);
        if (unlikely(eq != 0)) {
            if (unlikely(eq < 0)) return NULL;
            return kwvalues[i];
        }
    }
    return NULL;
}
#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API
CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) {
    Py_ssize_t i, nkwargs;
    PyObject *dict;
#if !CYTHON_ASSUME_SAFE_SIZE
    nkwargs = PyTuple_Size(kwnames);
    if (unlikely(nkwargs < 0)) return NULL;
#else
    nkwargs = PyTuple_GET_SIZE(kwnames);
#endif
    dict = PyDict_New();
    if (unlikely(!dict))
        return NULL;
    for (i=0; i<nkwargs; i++) {
#if !CYTHON_ASSUME_SAFE_MACROS
        PyObject *key = PyTuple_GetItem(kwnames, i);
        if (!key) goto bad;
#else
        PyObject *key = PyTuple_GET_ITEM(kwnames, i);
#endif
        if (unlikely(PyDict_SetItem(dict, key, kwvalues[i]) < 0))
            goto bad;
    }
    return dict;
bad:
    Py_DECREF(dict);
    return NULL;
}
#endif
#endif

/* DictGetItem */
#if !CYTHON_COMPILING_IN_PYPY
static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
    PyObject *value;
    if (unlikely(__Pyx_PyDict_GetItemRef(d, key, &value) == 0)) { // no value, no error
        if (unlikely(PyTuple_Check(key))) {
            PyObject* args = PyTuple_Pack(1, key);
            if (likely(args)) {
                PyErr_SetObject(PyExc_KeyError, args);
                Py_DECREF(args);
            }
        } else {
            PyErr_SetObject(PyExc_KeyError, key);
        }
    }
    return value;
}
#endif

/* PyObjectCallOneArg (used by CallUnboundCMethod0) */
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
    PyObject *args[2] = {NULL, arg};
    return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
}

/* UnpackUnboundCMethod (used by CallUnboundCMethod0) */
#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000
static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *args, PyObject *kwargs) {
    PyObject *result;
    PyObject *selfless_args = PyTuple_GetSlice(args, 1, PyTuple_Size(args));
    if (unlikely(!selfless_args)) return NULL;
    result = PyObject_Call(method, selfless_args, kwargs);
    Py_DECREF(selfless_args);
    return result;
}
#elif CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03090000
static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) {
        return _PyObject_Vectorcall
            (method, args ? args+1 : NULL, nargs ? nargs-1 : 0, kwnames);
}
#else
static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) {
    return
#if PY_VERSION_HEX < 0x03090000
    _PyObject_Vectorcall
#else
    PyObject_Vectorcall
#endif
        (method, args ? args+1 : NULL, nargs ? (size_t) nargs-1 : 0, kwnames);
}
#endif
static PyMethodDef __Pyx_UnboundCMethod_Def = {
     "CythonUnboundCMethod",
     __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_SelflessCall),
#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000
     METH_VARARGS | METH_KEYWORDS,
#else
     METH_FASTCALL | METH_KEYWORDS,
#endif
     NULL
};
static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) {
    PyObject *method, *result=NULL;
    method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name);
    if (unlikely(!method))
        return -1;
    result = method;
#if CYTHON_COMPILING_IN_CPYTHON
    if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type)))
    {
        PyMethodDescrObject *descr = (PyMethodDescrObject*) method;
        target->func = descr->d_method->ml_meth;
        target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS);
    } else
#endif
#if CYTHON_COMPILING_IN_PYPY
#else
    if (PyCFunction_Check(method))
#endif
    {
        PyObject *self;
        int self_found;
#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY
        self = PyObject_GetAttrString(method, "__self__");
        if (!self) {
            PyErr_Clear();
        }
#else
        self = PyCFunction_GET_SELF(method);
#endif
        self_found = (self && self != Py_None);
#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY
        Py_XDECREF(self);
#endif
        if (self_found) {
            PyObject *unbound_method = PyCFunction_New(&__Pyx_UnboundCMethod_Def, method);
            if (unlikely(!unbound_method)) return -1;
            Py_DECREF(method);
            result = unbound_method;
        }
    }
#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
    if (unlikely(target->method)) {
        Py_DECREF(result);
    } else
#endif
    target->method = result;
    return 0;
}

/* CallUnboundCMethod0 */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) {
    int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc);
    if (likely(was_initialized == 2 && cfunc->func)) {
        if (likely(cfunc->flag == METH_NOARGS))
            return __Pyx_CallCFunction(cfunc, self, NULL);
        if (likely(cfunc->flag == METH_FASTCALL))
            return __Pyx_CallCFunctionFast(cfunc, self, NULL, 0);
        if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS))
            return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, NULL, 0, NULL);
        if (likely(cfunc->flag == (METH_VARARGS | METH_KEYWORDS)))
            return __Pyx_CallCFunctionWithKeywords(cfunc, self, __pyx_mstate_global->__pyx_empty_tuple, NULL);
        if (cfunc->flag == METH_VARARGS)
            return __Pyx_CallCFunction(cfunc, self, __pyx_mstate_global->__pyx_empty_tuple);
        return __Pyx__CallUnboundCMethod0(cfunc, self);
    }
#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
    else if (unlikely(was_initialized == 1)) {
        __Pyx_CachedCFunction tmp_cfunc = {
#ifndef __cplusplus
            0
#endif
        };
        tmp_cfunc.type = cfunc->type;
        tmp_cfunc.method_name = cfunc->method_name;
        return __Pyx__CallUnboundCMethod0(&tmp_cfunc, self);
    }
#endif
    PyObject *result = __Pyx__CallUnboundCMethod0(cfunc, self);
    __Pyx_CachedCFunction_SetFinishedInitializing(cfunc);
    return result;
}
#endif
static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) {
    PyObject *result;
    if (unlikely(!cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL;
    result = __Pyx_PyObject_CallOneArg(cfunc->method, self);
    return result;
}

/* py_dict_items (used by OwnedDictNext) */
static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d) {
    return __Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_items, d);
}

/* py_dict_values (used by OwnedDictNext) */
static CYTHON_INLINE PyObject* __Pyx_PyDict_Values(PyObject* d) {
    return __Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_values, d);
}

/* OwnedDictNext (used by ParseKeywordsImpl) */
#if CYTHON_AVOID_BORROWED_REFS
static int __Pyx_PyDict_NextRef(PyObject *p, PyObject **ppos, PyObject **pkey, PyObject **pvalue) {
    PyObject *next = NULL;
    if (!*ppos) {
        if (pvalue) {
            PyObject *dictview = pkey ? __Pyx_PyDict_Items(p) : __Pyx_PyDict_Values(p);
            if (unlikely(!dictview)) goto bad;
            *ppos = PyObject_GetIter(dictview);
            Py_DECREF(dictview);
        } else {
            *ppos = PyObject_GetIter(p);
        }
        if (unlikely(!*ppos)) goto bad;
    }
    next = PyIter_Next(*ppos);
    if (!next) {
        if (PyErr_Occurred()) goto bad;
        return 0;
    }
    if (pkey && pvalue) {
        *pkey = __Pyx_PySequence_ITEM(next, 0);
        if (unlikely(*pkey)) goto bad;
        *pvalue = __Pyx_PySequence_ITEM(next, 1);
        if (unlikely(*pvalue)) goto bad;
        Py_DECREF(next);
    } else if (pkey) {
        *pkey = next;
    } else {
        assert(pvalue);
        *pvalue = next;
    }
    return 1;
  bad:
    Py_XDECREF(next);
#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000
    PyErr_FormatUnraisable("Exception ignored in __Pyx_PyDict_NextRef");
#else
    PyErr_WriteUnraisable(__pyx_mstate_global->__pyx_n_u_Pyx_PyDict_NextRef);
#endif
    if (pkey) *pkey = NULL;
    if (pvalue) *pvalue = NULL;
    return 0;
}
#else // !CYTHON_AVOID_BORROWED_REFS
static int __Pyx_PyDict_NextRef(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue) {
    int result = PyDict_Next(p, ppos, pkey, pvalue);
    if (likely(result == 1)) {
        if (pkey) Py_INCREF(*pkey);
        if (pvalue) Py_INCREF(*pvalue);
    }
    return result;
}
#endif

/* RaiseDoubleKeywords (used by ParseKeywordsImpl) */
static void __Pyx_RaiseDoubleKeywordsError(
    const char* func_name,
    PyObject* kw_name)
{
    PyErr_Format(PyExc_TypeError,
        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
}

/* CallUnboundCMethod2 */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2) {
    int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc);
    if (likely(was_initialized == 2 && cfunc->func)) {
        PyObject *args[2] = {arg1, arg2};
        if (cfunc->flag == METH_FASTCALL) {
            return __Pyx_CallCFunctionFast(cfunc, self, args, 2);
        }
        if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS))
            return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, 2, NULL);
    }
#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
    else if (unlikely(was_initialized == 1)) {
        __Pyx_CachedCFunction tmp_cfunc = {
#ifndef __cplusplus
            0
#endif
        };
        tmp_cfunc.type = cfunc->type;
        tmp_cfunc.method_name = cfunc->method_name;
        return __Pyx__CallUnboundCMethod2(&tmp_cfunc, self, arg1, arg2);
    }
#endif
    PyObject *result = __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2);
    __Pyx_CachedCFunction_SetFinishedInitializing(cfunc);
    return result;
}
#endif
static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2){
    if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL;
#if CYTHON_COMPILING_IN_CPYTHON
    if (cfunc->func && (cfunc->flag & METH_VARARGS)) {
        PyObject *result = NULL;
        PyObject *args = PyTuple_New(2);
        if (unlikely(!args)) return NULL;
        Py_INCREF(arg1);
        PyTuple_SET_ITEM(args, 0, arg1);
        Py_INCREF(arg2);
        PyTuple_SET_ITEM(args, 1, arg2);
        if (cfunc->flag & METH_KEYWORDS)
            result = __Pyx_CallCFunctionWithKeywords(cfunc, self, args, NULL);
        else
            result = __Pyx_CallCFunction(cfunc, self, args);
        Py_DECREF(args);
        return result;
    }
#endif
    {
        PyObject *args[4] = {NULL, self, arg1, arg2};
        return __Pyx_PyObject_FastCall(cfunc->method, args+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
    }
}

/* ParseKeywordsImpl (used by ParseKeywords) */
static int __Pyx_ValidateDuplicatePosArgs(
    PyObject *kwds,
    PyObject ** const argnames[],
    PyObject ** const *first_kw_arg,
    const char* function_name)
{
    PyObject ** const *name = argnames;
    while (name != first_kw_arg) {
        PyObject *key = **name;
        int found = PyDict_Contains(kwds, key);
        if (unlikely(found)) {
            if (found == 1) __Pyx_RaiseDoubleKeywordsError(function_name, key);
            goto bad;
        }
        name++;
    }
    return 0;
bad:
    return -1;
}
#if CYTHON_USE_UNICODE_INTERNALS
static CYTHON_INLINE int __Pyx_UnicodeKeywordsEqual(PyObject *s1, PyObject *s2) {
    int kind;
    Py_ssize_t len = PyUnicode_GET_LENGTH(s1);
    if (len != PyUnicode_GET_LENGTH(s2)) return 0;
    kind = PyUnicode_KIND(s1);
    if (kind != PyUnicode_KIND(s2)) return 0;
    const void *data1 = PyUnicode_DATA(s1);
    const void *data2 = PyUnicode_DATA(s2);
    return (memcmp(data1, data2, (size_t) len * (size_t) kind) == 0);
}
#endif
static int __Pyx_MatchKeywordArg_str(
    PyObject *key,
    PyObject ** const argnames[],
    PyObject ** const *first_kw_arg,
    size_t *index_found,
    const char *function_name)
{
    PyObject ** const *name;
    #if CYTHON_USE_UNICODE_INTERNALS
    Py_hash_t key_hash = ((PyASCIIObject*)key)->hash;
    if (unlikely(key_hash == -1)) {
        key_hash = PyObject_Hash(key);
        if (unlikely(key_hash == -1))
            goto bad;
    }
    #endif
    name = first_kw_arg;
    while (*name) {
        PyObject *name_str = **name;
        #if CYTHON_USE_UNICODE_INTERNALS
        if (key_hash == ((PyASCIIObject*)name_str)->hash && __Pyx_UnicodeKeywordsEqual(name_str, key)) {
            *index_found = (size_t) (name - argnames);
            return 1;
        }
        #else
        #if CYTHON_ASSUME_SAFE_SIZE
        if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key))
        #endif
        {
            int cmp = PyUnicode_Compare(name_str, key);
            if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
            if (cmp == 0) {
                *index_found = (size_t) (name - argnames);
                return 1;
            }
        }
        #endif
        name++;
    }
    name = argnames;
    while (name != first_kw_arg) {
        PyObject *name_str = **name;
        #if CYTHON_USE_UNICODE_INTERNALS
        if (unlikely(key_hash == ((PyASCIIObject*)name_str)->hash)) {
            if (__Pyx_UnicodeKeywordsEqual(name_str, key))
                goto arg_passed_twice;
        }
        #else
        #if CYTHON_ASSUME_SAFE_SIZE
        if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key))
        #endif
        {
            if (unlikely(name_str == key)) goto arg_passed_twice;
            int cmp = PyUnicode_Compare(name_str, key);
            if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
            if (cmp == 0) goto arg_passed_twice;
        }
        #endif
        name++;
    }
    return 0;
arg_passed_twice:
    __Pyx_RaiseDoubleKeywordsError(function_name, key);
    goto bad;
bad:
    return -1;
}
static int __Pyx_MatchKeywordArg_nostr(
    PyObject *key,
    PyObject ** const argnames[],
    PyObject ** const *first_kw_arg,
    size_t *index_found,
    const char *function_name)
{
    PyObject ** const *name;
    if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type;
    name = first_kw_arg;
    while (*name) {
        int cmp = PyObject_RichCompareBool(**name, key, Py_EQ);
        if (cmp == 1) {
            *index_found = (size_t) (name - argnames);
            return 1;
        }
        if (unlikely(cmp == -1)) goto bad;
        name++;
    }
    name = argnames;
    while (name != first_kw_arg) {
        int cmp = PyObject_RichCompareBool(**name, key, Py_EQ);
        if (unlikely(cmp != 0)) {
            if (cmp == 1) goto arg_passed_twice;
            else goto bad;
        }
        name++;
    }
    return 0;
arg_passed_twice:
    __Pyx_RaiseDoubleKeywordsError(function_name, key);
    goto bad;
invalid_keyword_type:
    PyErr_Format(PyExc_TypeError,
        "%.200s() keywords must be strings", function_name);
    goto bad;
bad:
    return -1;
}
static CYTHON_INLINE int __Pyx_MatchKeywordArg(
    PyObject *key,
    PyObject ** const argnames[],
    PyObject ** const *first_kw_arg,
    size_t *index_found,
    const char *function_name)
{
    return likely(PyUnicode_CheckExact(key)) ?
        __Pyx_MatchKeywordArg_str(key, argnames, first_kw_arg, index_found, function_name) :
        __Pyx_MatchKeywordArg_nostr(key, argnames, first_kw_arg, index_found, function_name);
}
static void __Pyx_RejectUnknownKeyword(
    PyObject *kwds,
    PyObject ** const argnames[],
    PyObject ** const *first_kw_arg,
    const char *function_name)
{
    #if CYTHON_AVOID_BORROWED_REFS
    PyObject *pos = NULL;
    #else
    Py_ssize_t pos = 0;
    #endif
    PyObject *key = NULL;
    __Pyx_BEGIN_CRITICAL_SECTION(kwds);
    while (
        #if CYTHON_AVOID_BORROWED_REFS
        __Pyx_PyDict_NextRef(kwds, &pos, &key, NULL)
        #else
        PyDict_Next(kwds, &pos, &key, NULL)
        #endif
    ) {
        PyObject** const *name = first_kw_arg;
        while (*name && (**name != key)) name++;
        if (!*name) {
            size_t index_found = 0;
            int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name);
            if (cmp != 1) {
                if (cmp == 0) {
                    PyErr_Format(PyExc_TypeError,
                        "%s() got an unexpected keyword argument '%U'",
                        function_name, key);
                }
                #if CYTHON_AVOID_BORROWED_REFS
                Py_DECREF(key);
                #endif
                break;
            }
        }
        #if CYTHON_AVOID_BORROWED_REFS
        Py_DECREF(key);
        #endif
    }
    __Pyx_END_CRITICAL_SECTION();
    #if CYTHON_AVOID_BORROWED_REFS
    Py_XDECREF(pos);
    #endif
    assert(PyErr_Occurred());
}
static int __Pyx_ParseKeywordDict(
    PyObject *kwds,
    PyObject ** const argnames[],
    PyObject *values[],
    Py_ssize_t num_pos_args,
    Py_ssize_t num_kwargs,
    const char* function_name,
    int ignore_unknown_kwargs)
{
    PyObject** const *name;
    PyObject** const *first_kw_arg = argnames + num_pos_args;
    Py_ssize_t extracted = 0;
#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments)
    if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1;
#endif
    name = first_kw_arg;
    while (*name && num_kwargs > extracted) {
        PyObject * key = **name;
        PyObject *value;
        int found = 0;
        #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
        found = PyDict_GetItemRef(kwds, key, &value);
        #else
        value = PyDict_GetItemWithError(kwds, key);
        if (value) {
            Py_INCREF(value);
            found = 1;
        } else {
            if (unlikely(PyErr_Occurred())) goto bad;
        }
        #endif
        if (found) {
            if (unlikely(found < 0)) goto bad;
            values[name-argnames] = value;
            extracted++;
        }
        name++;
    }
    if (num_kwargs > extracted) {
        if (ignore_unknown_kwargs) {
            if (unlikely(__Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name) == -1))
                goto bad;
        } else {
            __Pyx_RejectUnknownKeyword(kwds, argnames, first_kw_arg, function_name);
            goto bad;
        }
    }
    return 0;
bad:
    return -1;
}
static int __Pyx_ParseKeywordDictToDict(
    PyObject *kwds,
    PyObject ** const argnames[],
    PyObject *kwds2,
    PyObject *values[],
    Py_ssize_t num_pos_args,
    const char* function_name)
{
    PyObject** const *name;
    PyObject** const *first_kw_arg = argnames + num_pos_args;
    Py_ssize_t len;
#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments)
    if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1;
#endif
    if (PyDict_Update(kwds2, kwds) < 0) goto bad;
    name = first_kw_arg;
    while (*name) {
        PyObject *key = **name;
        PyObject *value;
#if !CYTHON_COMPILING_IN_LIMITED_API && (PY_VERSION_HEX >= 0x030d00A2 || defined(PyDict_Pop))
        int found = PyDict_Pop(kwds2, key, &value);
        if (found) {
            if (unlikely(found < 0)) goto bad;
            values[name-argnames] = value;
        }
#elif __PYX_LIMITED_VERSION_HEX >= 0x030d0000
        int found = PyDict_GetItemRef(kwds2, key, &value);
        if (found) {
            if (unlikely(found < 0)) goto bad;
            values[name-argnames] = value;
            if (unlikely(PyDict_DelItem(kwds2, key) < 0)) goto bad;
        }
#else
    #if CYTHON_COMPILING_IN_CPYTHON
        value = _PyDict_Pop(kwds2, key, kwds2);
    #else
        value = __Pyx_CallUnboundCMethod2(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_pop, kwds2, key, kwds2);
    #endif
        if (value == kwds2) {
            Py_DECREF(value);
        } else {
            if (unlikely(!value)) goto bad;
            values[name-argnames] = value;
        }
#endif
        name++;
    }
    len = PyDict_Size(kwds2);
    if (len > 0) {
        return __Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name);
    } else if (unlikely(len == -1)) {
        goto bad;
    }
    return 0;
bad:
    return -1;
}
static int __Pyx_ParseKeywordsTuple(
    PyObject *kwds,
    PyObject * const *kwvalues,
    PyObject ** const argnames[],
    PyObject *kwds2,
    PyObject *values[],
    Py_ssize_t num_pos_args,
    Py_ssize_t num_kwargs,
    const char* function_name,
    int ignore_unknown_kwargs)
{
    PyObject *key = NULL;
    PyObject** const * name;
    PyObject** const *first_kw_arg = argnames + num_pos_args;
    for (Py_ssize_t pos = 0; pos < num_kwargs; pos++) {
#if CYTHON_AVOID_BORROWED_REFS
        key = __Pyx_PySequence_ITEM(kwds, pos);
#else
        key = __Pyx_PyTuple_GET_ITEM(kwds, pos);
#endif
#if !CYTHON_ASSUME_SAFE_MACROS
        if (unlikely(!key)) goto bad;
#endif
        name = first_kw_arg;
        while (*name && (**name != key)) name++;
        if (*name) {
            PyObject *value = kwvalues[pos];
            values[name-argnames] = __Pyx_NewRef(value);
        } else {
            size_t index_found = 0;
            int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name);
            if (cmp == 1) {
                PyObject *value = kwvalues[pos];
                values[index_found] = __Pyx_NewRef(value);
            } else {
                if (unlikely(cmp == -1)) goto bad;
                if (kwds2) {
                    PyObject *value = kwvalues[pos];
                    if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
                } else if (!ignore_unknown_kwargs) {
                    goto invalid_keyword;
                }
            }
        }
        #if CYTHON_AVOID_BORROWED_REFS
        Py_DECREF(key);
        key = NULL;
        #endif
    }
    return 0;
invalid_keyword:
    PyErr_Format(PyExc_TypeError,
        "%s() got an unexpected keyword argument '%U'",
        function_name, key);
    goto bad;
bad:
    #if CYTHON_AVOID_BORROWED_REFS
    Py_XDECREF(key);
    #endif
    return -1;
}

/* ParseKeywords */
static int __Pyx_ParseKeywords(
    PyObject *kwds,
    PyObject * const *kwvalues,
    PyObject ** const argnames[],
    PyObject *kwds2,
    PyObject *values[],
    Py_ssize_t num_pos_args,
    Py_ssize_t num_kwargs,
    const char* function_name,
    int ignore_unknown_kwargs)
{
    if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)))
        return __Pyx_ParseKeywordsTuple(kwds, kwvalues, argnames, kwds2, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs);
    else if (kwds2)
        return __Pyx_ParseKeywordDictToDict(kwds, argnames, kwds2, values, num_pos_args, function_name);
    else
        return __Pyx_ParseKeywordDict(kwds, argnames, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs);
}

/* RaiseArgTupleInvalid */
static void __Pyx_RaiseArgtupleInvalid(
    const char* func_name,
    int exact,
    Py_ssize_t num_min,
    Py_ssize_t num_max,
    Py_ssize_t num_found)
{
    Py_ssize_t num_expected;
    const char *more_or_less;
    if (num_found < num_min) {
        num_expected = num_min;
        more_or_less = "at least";
    } else {
        num_expected = num_max;
        more_or_less = "at most";
    }
    if (exact) {
        more_or_less = "exactly";
    }
    PyErr_Format(PyExc_TypeError,
                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
                 func_name, more_or_less, num_expected,
                 (num_expected == 1) ? "" : "s", num_found);
}

/* ArgTypeTestFunc (used by ArgTypeTest) */
static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact)
{
    __Pyx_TypeName type_name;
    __Pyx_TypeName obj_type_name;
    PyObject *extra_info = __pyx_mstate_global->__pyx_empty_unicode;
    int from_annotation_subclass = 0;
    if (unlikely(!type)) {
        PyErr_SetString(PyExc_SystemError, "Missing type object");
        return 0;
    }
    else if (!exact) {
        if (likely(__Pyx_TypeCheck(obj, type))) return 1;
    } else if (exact == 2) {
        if (__Pyx_TypeCheck(obj, type)) {
            from_annotation_subclass = 1;
            extra_info = __pyx_mstate_global->__pyx_kp_u_Note_that_Cython_is_deliberately;
        }
    }
    type_name = __Pyx_PyType_GetFullyQualifiedName(type);
    obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj));
    PyErr_Format(PyExc_TypeError,
        "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME
        ", got " __Pyx_FMT_TYPENAME ")"
#if __PYX_LIMITED_VERSION_HEX < 0x030C0000
        "%s%U"
#endif
        , name, type_name, obj_type_name
#if __PYX_LIMITED_VERSION_HEX < 0x030C0000
        , (from_annotation_subclass ? ". " : ""), extra_info
#endif
        );
#if __PYX_LIMITED_VERSION_HEX >= 0x030C0000
    if (exact == 2 && from_annotation_subclass) {
        PyObject *res;
        PyObject *vargs[2];
        vargs[0] = PyErr_GetRaisedException();
        vargs[1] = extra_info;
        res = PyObject_VectorcallMethod(__pyx_mstate_global->__pyx_kp_u_add_note, vargs, 2, NULL);
        Py_XDECREF(res);
        PyErr_SetRaisedException(vargs[0]);
    }
#endif
    __Pyx_DECREF_TypeName(type_name);
    __Pyx_DECREF_TypeName(obj_type_name);
    return 0;
}

/* FunctionExport */
static int __Pyx_ExportFunction(PyObject *api_dict, const char *name, void (*f)(void), const char *sig) {
    PyObject *cobj;
    union {
        void (*fp)(void);
        void *p;
    } tmp;
    tmp.fp = f;
    cobj = PyCapsule_New(tmp.p, sig, 0);
    if (!cobj)
        goto bad;
    if (PyDict_SetItemString(api_dict, name, cobj) < 0)
        goto bad;
    Py_DECREF(cobj);
    return 0;
bad:
    Py_XDECREF(cobj);
    return -1;
}

/* GetApiDict */
static PyObject *__Pyx_ApiExport_GetApiDict(void) {
    PyObject *d;
    if (__Pyx_PyDict_GetItemRef(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pyx_capi, &d) == -1)
        return NULL;
    if (!d) {
        d = PyDict_New();
        if (!d)
            goto bad;
        if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_pyx_capi, d) < 0)
            goto bad;
    }
    return d;
bad:
    Py_XDECREF(d);
    return NULL;
}

/* HasAttr (used by ImportImpl) */
#if __PYX_LIMITED_VERSION_HEX < 0x030d0000
static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) {
    PyObject *r;
    if (unlikely(!PyUnicode_Check(n))) {
        PyErr_SetString(PyExc_TypeError,
                        "hasattr(): attribute name must be string");
        return -1;
    }
    r = __Pyx_PyObject_GetAttrStrNoError(o, n);
    if (!r) {
        return (unlikely(PyErr_Occurred())) ? -1 : 0;
    } else {
        Py_DECREF(r);
        return 1;
    }
}
#endif

/* ImportImpl (used by Import) */
static int __Pyx__Import_GetModule(PyObject *qualname, PyObject **module) {
    PyObject *imported_module = PyImport_GetModule(qualname);
    if (unlikely(!imported_module)) {
        *module = NULL;
        if (PyErr_Occurred()) {
            return -1;
        }
        return 0;
    }
    *module = imported_module;
    return 1;
}
static int __Pyx__Import_Lookup(PyObject *qualname, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject **module) {
    PyObject *imported_module;
    PyObject *top_level_package_name;
    Py_ssize_t i;
    int status, module_found;
    Py_ssize_t dot_index;
    module_found = __Pyx__Import_GetModule(qualname, &imported_module);
    if (unlikely(!module_found || module_found == -1)) {
        *module = NULL;
        return module_found;
    }
    if (imported_names) {
        for (i = 0; i < len_imported_names; i++) {
            PyObject *imported_name = imported_names[i];
#if __PYX_LIMITED_VERSION_HEX < 0x030d0000
            int has_imported_attribute = PyObject_HasAttr(imported_module, imported_name);
#else
            int has_imported_attribute = PyObject_HasAttrWithError(imported_module, imported_name);
            if (unlikely(has_imported_attribute == -1)) goto error;
#endif
            if (!has_imported_attribute) {
                goto not_found;
            }
        }
        *module = imported_module;
        return 1;
    }
    dot_index = PyUnicode_FindChar(qualname, '.', 0, PY_SSIZE_T_MAX, 1);
    if (dot_index == -1) {
        *module = imported_module;
        return 1;
    }
    if (unlikely(dot_index == -2)) goto error;
    top_level_package_name = PyUnicode_Substring(qualname, 0, dot_index);
    if (unlikely(!top_level_package_name)) goto error;
    Py_DECREF(imported_module);
    status = __Pyx__Import_GetModule(top_level_package_name, module);
    Py_DECREF(top_level_package_name);
    return status;
error:
    Py_DECREF(imported_module);
    *module = NULL;
    return -1;
not_found:
    Py_DECREF(imported_module);
    *module = NULL;
    return 0;
}
static PyObject *__Pyx__Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, PyObject *moddict, int level) {
    PyObject *module = 0;
    PyObject *empty_dict = 0;
    PyObject *from_list = 0;
    int module_found;
    if (!qualname) {
        qualname = name;
    }
    module_found = __Pyx__Import_Lookup(qualname, imported_names, len_imported_names, &module);
    if (likely(module_found == 1)) {
        return module;
    } else if (unlikely(module_found == -1)) {
        return NULL;
    }
    empty_dict = PyDict_New();
    if (unlikely(!empty_dict))
        goto bad;
    if (imported_names) {
#if CYTHON_COMPILING_IN_CPYTHON
        from_list = __Pyx_PyList_FromArray(imported_names, len_imported_names);
        if (unlikely(!from_list))
            goto bad;
#else
        from_list = PyList_New(len_imported_names);
        if (unlikely(!from_list)) goto bad;
        for (Py_ssize_t i=0; i<len_imported_names; ++i) {
            if (PyList_SetItem(from_list, i, __Pyx_NewRef(imported_names[i])) < 0) goto bad;
        }
#endif
    }
    if (level == -1) {
        const char* package_sep = strchr(__Pyx_MODULE_NAME, '.');
        if (package_sep != (0)) {
            module = PyImport_ImportModuleLevelObject(
                name, moddict, empty_dict, from_list, 1);
            if (unlikely(!module)) {
                if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError)))
                    goto bad;
                PyErr_Clear();
            }
        }
        level = 0;
    }
    if (!module) {
        module = PyImport_ImportModuleLevelObject(
            name, moddict, empty_dict, from_list, level);
    }
bad:
    Py_XDECREF(from_list);
    Py_XDECREF(empty_dict);
    return module;
}

/* Import */
static PyObject *__Pyx_Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, int level) {
    return __Pyx__Import(name, imported_names, len_imported_names, qualname, __pyx_mstate_global->__pyx_d, level);
}

/* ImportFrom */
static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) {
    PyObject* value = __Pyx_PyObject_GetAttrStr(module, name);
    if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) {
        const char* module_name_str = 0;
        PyObject* module_name = 0;
        PyObject* module_dot = 0;
        PyObject* full_name = 0;
        PyErr_Clear();
        module_name_str = PyModule_GetName(module);
        if (unlikely(!module_name_str)) { goto modbad; }
        module_name = PyUnicode_FromString(module_name_str);
        if (unlikely(!module_name)) { goto modbad; }
        module_dot = PyUnicode_Concat(module_name, __pyx_mstate_global->__pyx_kp_u__2);
        if (unlikely(!module_dot)) { goto modbad; }
        full_name = PyUnicode_Concat(module_dot, name);
        if (unlikely(!full_name)) { goto modbad; }
        #if (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM  < 0x07030400) ||\
                CYTHON_COMPILING_IN_GRAAL
        {
            PyObject *modules = PyImport_GetModuleDict();
            if (unlikely(!modules))
                goto modbad;
            value = PyObject_GetItem(modules, full_name);
        }
        #else
        value = PyImport_GetModule(full_name);
        #endif
      modbad:
        Py_XDECREF(full_name);
        Py_XDECREF(module_dot);
        Py_XDECREF(module_name);
    }
    if (unlikely(!value)) {
        PyErr_Format(PyExc_ImportError, "cannot import name %S", name);
    }
    return value;
}

/* dict_setdefault (used by FetchCommonType) */
static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value) {
    PyObject* value;
#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX >= 0x030C0000
    PyObject *args[] = {d, key, default_value};
    value = PyObject_VectorcallMethod(__pyx_mstate_global->__pyx_n_u_setdefault, args, 3 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
#elif CYTHON_COMPILING_IN_LIMITED_API
    value = PyObject_CallMethodObjArgs(d, __pyx_mstate_global->__pyx_n_u_setdefault, key, default_value, NULL);
#elif PY_VERSION_HEX >= 0x030d0000
    PyDict_SetDefaultRef(d, key, default_value, &value);
#else
    value = PyDict_SetDefault(d, key, default_value);
    if (unlikely(!value)) return NULL;
    Py_INCREF(value);
#endif
    return value;
}

/* LimitedApiGetTypeDict (used by SetItemOnTypeDict) */
#if CYTHON_COMPILING_IN_LIMITED_API
static Py_ssize_t __Pyx_GetTypeDictOffset(void) {
    PyObject *tp_dictoffset_o;
    Py_ssize_t tp_dictoffset;
    tp_dictoffset_o = PyObject_GetAttrString((PyObject*)(&PyType_Type), "__dictoffset__");
    if (unlikely(!tp_dictoffset_o)) return -1;
    tp_dictoffset = PyLong_AsSsize_t(tp_dictoffset_o);
    Py_DECREF(tp_dictoffset_o);
    if (unlikely(tp_dictoffset == 0)) {
        PyErr_SetString(
            PyExc_TypeError,
            "'type' doesn't have a dictoffset");
        return -1;
    } else if (unlikely(tp_dictoffset < 0)) {
        PyErr_SetString(
            PyExc_TypeError,
            "'type' has an unexpected negative dictoffset. "
            "Please report this as Cython bug");
        return -1;
    }
    return tp_dictoffset;
}
static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp) {
    static Py_ssize_t tp_dictoffset = 0;
    if (unlikely(tp_dictoffset == 0)) {
        tp_dictoffset = __Pyx_GetTypeDictOffset();
        if (unlikely(tp_dictoffset == -1 && PyErr_Occurred())) {
            tp_dictoffset = 0; // try again next time?
            return NULL;
        }
    }
    return *(PyObject**)((char*)tp + tp_dictoffset);
}
#endif

/* SetItemOnTypeDict (used by FixUpExtensionType) */
static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v) {
    int result;
    PyObject *tp_dict;
#if CYTHON_COMPILING_IN_LIMITED_API
    tp_dict = __Pyx_GetTypeDict(tp);
    if (unlikely(!tp_dict)) return -1;
#else
    tp_dict = tp->tp_dict;
#endif
    result = PyDict_SetItem(tp_dict, k, v);
    if (likely(!result)) {
        PyType_Modified(tp);
        if (unlikely(PyObject_HasAttr(v, __pyx_mstate_global->__pyx_n_u_set_name))) {
            PyObject *setNameResult = PyObject_CallMethodObjArgs(v, __pyx_mstate_global->__pyx_n_u_set_name,  (PyObject *) tp, k, NULL);
            if (!setNameResult) return -1;
            Py_DECREF(setNameResult);
        }
    }
    return result;
}

/* FixUpExtensionType (used by FetchCommonType) */
static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) {
#if __PYX_LIMITED_VERSION_HEX > 0x030900B1
    CYTHON_UNUSED_VAR(spec);
    CYTHON_UNUSED_VAR(type);
    CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict);
#else
    const PyType_Slot *slot = spec->slots;
    int changed = 0;
#if !CYTHON_COMPILING_IN_LIMITED_API
    while (slot && slot->slot && slot->slot != Py_tp_members)
        slot++;
    if (slot && slot->slot == Py_tp_members) {
#if !CYTHON_COMPILING_IN_CPYTHON
        const
#endif  // !CYTHON_COMPILING_IN_CPYTHON)
            PyMemberDef *memb = (PyMemberDef*) slot->pfunc;
        while (memb && memb->name) {
            if (memb->name[0] == '_' && memb->name[1] == '_') {
                if (strcmp(memb->name, "__weaklistoffset__") == 0) {
                    assert(memb->type == T_PYSSIZET);
                    assert(memb->flags == READONLY);
                    type->tp_weaklistoffset = memb->offset;
                    changed = 1;
                }
                else if (strcmp(memb->name, "__dictoffset__") == 0) {
                    assert(memb->type == T_PYSSIZET);
                    assert(memb->flags == READONLY);
                    type->tp_dictoffset = memb->offset;
                    changed = 1;
                }
#if CYTHON_METH_FASTCALL
                else if (strcmp(memb->name, "__vectorcalloffset__") == 0) {
                    assert(memb->type == T_PYSSIZET);
                    assert(memb->flags == READONLY);
                    type->tp_vectorcall_offset = memb->offset;
                    changed = 1;
                }
#endif  // CYTHON_METH_FASTCALL
#if !CYTHON_COMPILING_IN_PYPY
                else if (strcmp(memb->name, "__module__") == 0) {
                    PyObject *descr;
                    assert(memb->type == T_OBJECT);
                    assert(memb->flags == 0 || memb->flags == READONLY);
                    descr = PyDescr_NewMember(type, memb);
                    if (unlikely(!descr))
                        return -1;
                    int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr);
                    Py_DECREF(descr);
                    if (unlikely(set_item_result < 0)) {
                        return -1;
                    }
                    changed = 1;
                }
#endif  // !CYTHON_COMPILING_IN_PYPY
            }
            memb++;
        }
    }
#endif  // !CYTHON_COMPILING_IN_LIMITED_API
#if !CYTHON_COMPILING_IN_PYPY
    slot = spec->slots;
    while (slot && slot->slot && slot->slot != Py_tp_getset)
        slot++;
    if (slot && slot->slot == Py_tp_getset) {
        PyGetSetDef *getset = (PyGetSetDef*) slot->pfunc;
        while (getset && getset->name) {
            if (getset->name[0] == '_' && getset->name[1] == '_' && strcmp(getset->name, "__module__") == 0) {
                PyObject *descr = PyDescr_NewGetSet(type, getset);
                if (unlikely(!descr))
                    return -1;
                #if CYTHON_COMPILING_IN_LIMITED_API
                PyObject *pyname = PyUnicode_FromString(getset->name);
                if (unlikely(!pyname)) {
                    Py_DECREF(descr);
                    return -1;
                }
                int set_item_result = __Pyx_SetItemOnTypeDict(type, pyname, descr);
                Py_DECREF(pyname);
                #else
                CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict);
                int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr);
                #endif
                Py_DECREF(descr);
                if (unlikely(set_item_result < 0)) {
                    return -1;
                }
                changed = 1;
            }
            ++getset;
        }
    }
#else
    CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict);
#endif  // !CYTHON_COMPILING_IN_PYPY
    if (changed)
        PyType_Modified(type);
#endif  // PY_VERSION_HEX > 0x030900B1
    return 0;
}

/* AddModuleRef (used by FetchSharedCythonModule) */
#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
  static PyObject *__Pyx_PyImport_AddModuleObjectRef(PyObject *name) {
      PyObject *module_dict = PyImport_GetModuleDict();
      PyObject *m;
      if (PyMapping_GetOptionalItem(module_dict, name, &m) < 0) {
          return NULL;
      }
      if (m != NULL && PyModule_Check(m)) {
          return m;
      }
      Py_XDECREF(m);
      m = PyModule_NewObject(name);
      if (m == NULL)
          return NULL;
      if (PyDict_CheckExact(module_dict)) {
          PyObject *new_m;
          (void)PyDict_SetDefaultRef(module_dict, name, m, &new_m);
          Py_DECREF(m);
          return new_m;
      } else {
           if (PyObject_SetItem(module_dict, name, m) != 0) {
                Py_DECREF(m);
                return NULL;
            }
            return m;
      }
  }
  static PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
      PyObject *py_name = PyUnicode_FromString(name);
      if (!py_name) return NULL;
      PyObject *module = __Pyx_PyImport_AddModuleObjectRef(py_name);
      Py_DECREF(py_name);
      return module;
  }
#elif __PYX_LIMITED_VERSION_HEX >= 0x030d0000
  #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
#else
  static PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
      PyObject *module = PyImport_AddModule(name);
      Py_XINCREF(module);
      return module;
  }
#endif

/* FetchSharedCythonModule (used by FetchCommonType) */
static PyObject *__Pyx_FetchSharedCythonABIModule(void) {
    return __Pyx_PyImport_AddModuleRef(__PYX_ABI_MODULE_NAME);
}

/* FetchCommonType (used by CommonTypesMetaclass) */
#if __PYX_LIMITED_VERSION_HEX < 0x030C0000
static PyObject* __Pyx_PyType_FromMetaclass(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) {
    PyObject *result = __Pyx_PyType_FromModuleAndSpec(module, spec, bases);
    if (result && metaclass) {
        PyObject *old_tp = (PyObject*)Py_TYPE(result);
    Py_INCREF((PyObject*)metaclass);
#if __PYX_LIMITED_VERSION_HEX >= 0x03090000
        Py_SET_TYPE(result, metaclass);
#else
        result->ob_type = metaclass;
#endif
        Py_DECREF(old_tp);
    }
    return result;
}
#else
#define __Pyx_PyType_FromMetaclass(me, mo, s, b) PyType_FromMetaclass(me, mo, s, b)
#endif
static int __Pyx_VerifyCachedType(PyObject *cached_type,
                               const char *name,
                               Py_ssize_t expected_basicsize) {
    Py_ssize_t basicsize;
    if (!PyType_Check(cached_type)) {
        PyErr_Format(PyExc_TypeError,
            "Shared Cython type %.200s is not a type object", name);
        return -1;
    }
    if (expected_basicsize == 0) {
        return 0; // size is inherited, nothing useful to check
    }
#if CYTHON_COMPILING_IN_LIMITED_API
    PyObject *py_basicsize;
    py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__");
    if (unlikely(!py_basicsize)) return -1;
    basicsize = PyLong_AsSsize_t(py_basicsize);
    Py_DECREF(py_basicsize);
    py_basicsize = NULL;
    if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) return -1;
#else
    basicsize = ((PyTypeObject*) cached_type)->tp_basicsize;
#endif
    if (basicsize != expected_basicsize) {
        PyErr_Format(PyExc_TypeError,
            "Shared Cython type %.200s has the wrong size, try recompiling",
            name);
        return -1;
    }
    return 0;
}
static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) {
    PyObject *abi_module = NULL, *cached_type = NULL, *abi_module_dict, *new_cached_type, *py_object_name;
    int get_item_ref_result;
    const char* object_name = strrchr(spec->name, '.');
    object_name = object_name ? object_name+1 : spec->name;
    py_object_name = PyUnicode_FromString(object_name);
    if (!py_object_name) return NULL;
    abi_module = __Pyx_FetchSharedCythonABIModule();
    if (!abi_module) goto done;
    abi_module_dict = PyModule_GetDict(abi_module);
    if (!abi_module_dict) goto done;
    get_item_ref_result = __Pyx_PyDict_GetItemRef(abi_module_dict, py_object_name, &cached_type);
    if (get_item_ref_result == 1) {
        if (__Pyx_VerifyCachedType(
              cached_type,
              object_name,
              spec->basicsize) < 0) {
            goto bad;
        }
        goto done;
    } else if (unlikely(get_item_ref_result == -1)) {
        goto bad;
    }
    cached_type = __Pyx_PyType_FromMetaclass(
        metaclass,
        CYTHON_USE_MODULE_STATE ? module : abi_module,
        spec, bases);
    if (unlikely(!cached_type)) goto bad;
    if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad;
    new_cached_type = __Pyx_PyDict_SetDefault(abi_module_dict, py_object_name, cached_type);
    if (unlikely(new_cached_type != cached_type)) {
        if (unlikely(!new_cached_type)) goto bad;
        Py_DECREF(cached_type);
        cached_type = new_cached_type;
        if (__Pyx_VerifyCachedType(
                cached_type,
                object_name,
                spec->basicsize) < 0) {
            goto bad;
        }
        goto done;
    } else {
        Py_DECREF(new_cached_type);
    }
done:
    Py_XDECREF(abi_module);
    Py_DECREF(py_object_name);
    assert(cached_type == NULL || PyType_Check(cached_type));
    return (PyTypeObject *) cached_type;
bad:
    Py_XDECREF(cached_type);
    cached_type = NULL;
    goto done;
}

/* CommonTypesMetaclass (used by CythonFunctionShared) */
static PyObject* __pyx_CommonTypesMetaclass_get_module(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED void* context) {
    return PyUnicode_FromString(__PYX_ABI_MODULE_NAME);
}
#if __PYX_LIMITED_VERSION_HEX < 0x030A0000
static PyObject* __pyx_CommonTypesMetaclass_call(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED PyObject *args, CYTHON_UNUSED PyObject *kwds) {
    PyErr_SetString(PyExc_TypeError, "Cannot instantiate Cython internal types");
    return NULL;
}
static int __pyx_CommonTypesMetaclass_setattr(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED PyObject *attr, CYTHON_UNUSED PyObject *value) {
    PyErr_SetString(PyExc_TypeError, "Cython internal types are immutable");
    return -1;
}
#endif
static PyGetSetDef __pyx_CommonTypesMetaclass_getset[] = {
    {"__module__", __pyx_CommonTypesMetaclass_get_module, NULL, NULL, NULL},
    {0, 0, 0, 0, 0}
};
static PyType_Slot __pyx_CommonTypesMetaclass_slots[] = {
    {Py_tp_getset, (void *)__pyx_CommonTypesMetaclass_getset},
    #if __PYX_LIMITED_VERSION_HEX < 0x030A0000
    {Py_tp_call, (void*)__pyx_CommonTypesMetaclass_call},
    {Py_tp_new, (void*)__pyx_CommonTypesMetaclass_call},
    {Py_tp_setattro, (void*)__pyx_CommonTypesMetaclass_setattr},
    #endif
    {0, 0}
};
static PyType_Spec __pyx_CommonTypesMetaclass_spec = {
    __PYX_TYPE_MODULE_PREFIX "_common_types_metatype",
    0,
    0,
    Py_TPFLAGS_IMMUTABLETYPE |
    Py_TPFLAGS_DISALLOW_INSTANTIATION |
    Py_TPFLAGS_DEFAULT,
    __pyx_CommonTypesMetaclass_slots
};
static int __pyx_CommonTypesMetaclass_init(PyObject *module) {
    __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module);
    PyObject *bases = PyTuple_Pack(1, &PyType_Type);
    if (unlikely(!bases)) {
        return -1;
    }
    mstate->__pyx_CommonTypesMetaclassType = __Pyx_FetchCommonTypeFromSpec(NULL, module, &__pyx_CommonTypesMetaclass_spec, bases);
    Py_DECREF(bases);
    if (unlikely(mstate->__pyx_CommonTypesMetaclassType == NULL)) {
        return -1;
    }
    return 0;
}

/* CallTypeTraverse (used by CythonFunctionShared) */
#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000)
#else
static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg) {
    #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000
    if (__Pyx_get_runtime_version() < 0x03090000) return 0;
    #endif
    if (!always_call) {
        PyTypeObject *base = __Pyx_PyObject_GetSlot(o, tp_base, PyTypeObject*);
        unsigned long flags = PyType_GetFlags(base);
        if (flags & Py_TPFLAGS_HEAPTYPE) {
            return 0;
        }
    }
    Py_VISIT((PyObject*)Py_TYPE(o));
    return 0;
}
#endif

/* PyMethodNew (used by CythonFunctionShared) */
#if CYTHON_COMPILING_IN_LIMITED_API
static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
    PyObject *result;
    CYTHON_UNUSED_VAR(typ);
    if (!self)
        return __Pyx_NewRef(func);
    #if __PYX_LIMITED_VERSION_HEX >= 0x030C0000
    {
        PyObject *args[] = {func, self};
        result = PyObject_Vectorcall(__pyx_mstate_global->__Pyx_CachedMethodType, args, 2, NULL);
    }
    #else
    result = PyObject_CallFunctionObjArgs(__pyx_mstate_global->__Pyx_CachedMethodType, func, self, NULL);
    #endif
    return result;
}
#else
static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
    CYTHON_UNUSED_VAR(typ);
    if (!self)
        return __Pyx_NewRef(func);
    return PyMethod_New(func, self);
}
#endif

/* PyVectorcallFastCallDict (used by CythonFunctionShared) */
#if CYTHON_METH_FASTCALL && CYTHON_VECTORCALL
static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
{
    PyObject *res = NULL;
    PyObject *kwnames;
    PyObject **newargs;
    PyObject **kwvalues;
    Py_ssize_t i;
    #if CYTHON_AVOID_BORROWED_REFS
    PyObject *pos;
    #else
    Py_ssize_t pos;
    #endif
    size_t j;
    PyObject *key, *value;
    unsigned long keys_are_strings;
    #if !CYTHON_ASSUME_SAFE_SIZE
    Py_ssize_t nkw = PyDict_Size(kw);
    if (unlikely(nkw == -1)) return NULL;
    #else
    Py_ssize_t nkw = PyDict_GET_SIZE(kw);
    #endif
    newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0]));
    if (unlikely(newargs == NULL)) {
        PyErr_NoMemory();
        return NULL;
    }
    for (j = 0; j < nargs; j++) newargs[j] = args[j];
    kwnames = PyTuple_New(nkw);
    if (unlikely(kwnames == NULL)) {
        PyMem_Free(newargs);
        return NULL;
    }
    kwvalues = newargs + nargs;
    pos = 0;
    i = 0;
    keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS;
    while (__Pyx_PyDict_NextRef(kw, &pos, &key, &value)) {
        keys_are_strings &=
        #if CYTHON_COMPILING_IN_LIMITED_API
            PyType_GetFlags(Py_TYPE(key));
        #else
            Py_TYPE(key)->tp_flags;
        #endif
        #if !CYTHON_ASSUME_SAFE_MACROS
        if (unlikely(PyTuple_SetItem(kwnames, i, key) < 0)) goto cleanup;
        #else
        PyTuple_SET_ITEM(kwnames, i, key);
        #endif
        kwvalues[i] = value;
        i++;
    }
    if (unlikely(!keys_are_strings)) {
        PyErr_SetString(PyExc_TypeError, "keywords must be strings");
        goto cleanup;
    }
    res = vc(func, newargs, nargs, kwnames);
cleanup:
    #if CYTHON_AVOID_BORROWED_REFS
    Py_DECREF(pos);
    #endif
    Py_DECREF(kwnames);
    for (i = 0; i < nkw; i++)
        Py_DECREF(kwvalues[i]);
    PyMem_Free(newargs);
    return res;
}
static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
{
    Py_ssize_t kw_size =
        likely(kw == NULL) ?
        0 :
#if !CYTHON_ASSUME_SAFE_SIZE
        PyDict_Size(kw);
#else
        PyDict_GET_SIZE(kw);
#endif
    if (kw_size == 0) {
        return vc(func, args, nargs, NULL);
    }
#if !CYTHON_ASSUME_SAFE_SIZE
    else if (unlikely(kw_size == -1)) {
        return NULL;
    }
#endif
    return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw);
}
#endif

/* CythonFunctionShared (used by CythonFunction) */
#if CYTHON_COMPILING_IN_LIMITED_API
static CYTHON_INLINE int __Pyx__IsSameCyOrCFunctionNoMethod(PyObject *func, void (*cfunc)(void)) {
    if (__Pyx_CyFunction_Check(func)) {
        return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc;
    } else if (PyCFunction_Check(func)) {
        return PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
    }
    return 0;
}
static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) {
    if ((PyObject*)Py_TYPE(func) == __pyx_mstate_global->__Pyx_CachedMethodType) {
        int result;
        PyObject *newFunc = PyObject_GetAttr(func, __pyx_mstate_global->__pyx_n_u_func);
        if (unlikely(!newFunc)) {
            PyErr_Clear(); // It's only an optimization, so don't throw an error
            return 0;
        }
        result = __Pyx__IsSameCyOrCFunctionNoMethod(newFunc, cfunc);
        Py_DECREF(newFunc);
        return result;
    }
    return __Pyx__IsSameCyOrCFunctionNoMethod(func, cfunc);
}
#else
static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) {
    if (PyMethod_Check(func)) {
        func = PyMethod_GET_FUNCTION(func);
    }
    return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
}
#endif
static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) {
#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
    __Pyx_Py_XDECREF_SET(
        __Pyx_CyFunction_GetClassObj(f),
            ((classobj) ? __Pyx_NewRef(classobj) : NULL));
#else
    __Pyx_Py_XDECREF_SET(
        ((PyCMethodObject *) (f))->mm_class,
        (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL));
#endif
}
static PyObject *
__Pyx_CyFunction_get_doc_locked(__pyx_CyFunctionObject *op)
{
    if (unlikely(op->func_doc == NULL)) {
#if CYTHON_COMPILING_IN_LIMITED_API
        op->func_doc = PyObject_GetAttrString(op->func, "__doc__");
        if (unlikely(!op->func_doc)) return NULL;
#else
        if (((PyCFunctionObject*)op)->m_ml->ml_doc) {
            op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
            if (unlikely(op->func_doc == NULL))
                return NULL;
        } else {
            Py_INCREF(Py_None);
            return Py_None;
        }
#endif
    }
    Py_INCREF(op->func_doc);
    return op->func_doc;
}
static PyObject *
__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) {
    PyObject *result;
    CYTHON_UNUSED_VAR(closure);
    __Pyx_BEGIN_CRITICAL_SECTION(op);
    result = __Pyx_CyFunction_get_doc_locked(op);
    __Pyx_END_CRITICAL_SECTION();
    return result;
}
static int
__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context)
{
    CYTHON_UNUSED_VAR(context);
    if (value == NULL) {
        value = Py_None;
    }
    Py_INCREF(value);
    __Pyx_BEGIN_CRITICAL_SECTION(op);
    __Pyx_Py_XDECREF_SET(op->func_doc, value);
    __Pyx_END_CRITICAL_SECTION();
    return 0;
}
static PyObject *
__Pyx_CyFunction_get_name_locked(__pyx_CyFunctionObject *op)
{
    if (unlikely(op->func_name == NULL)) {
#if CYTHON_COMPILING_IN_LIMITED_API
        op->func_name = PyObject_GetAttrString(op->func, "__name__");
#else
        op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
#endif
        if (unlikely(op->func_name == NULL))
            return NULL;
    }
    Py_INCREF(op->func_name);
    return op->func_name;
}
static PyObject *
__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context)
{
    PyObject *result = NULL;
    CYTHON_UNUSED_VAR(context);
    __Pyx_BEGIN_CRITICAL_SECTION(op);
    result = __Pyx_CyFunction_get_name_locked(op);
    __Pyx_END_CRITICAL_SECTION();
    return result;
}
static int
__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context)
{
    CYTHON_UNUSED_VAR(context);
    if (unlikely(value == NULL || !PyUnicode_Check(value))) {
        PyErr_SetString(PyExc_TypeError,
                        "__name__ must be set to a string object");
        return -1;
    }
    Py_INCREF(value);
    __Pyx_BEGIN_CRITICAL_SECTION(op);
    __Pyx_Py_XDECREF_SET(op->func_name, value);
    __Pyx_END_CRITICAL_SECTION();
    return 0;
}
static PyObject *
__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context)
{
    CYTHON_UNUSED_VAR(context);
    PyObject *result;
    __Pyx_BEGIN_CRITICAL_SECTION(op);
    Py_INCREF(op->func_qualname);
    result = op->func_qualname;
    __Pyx_END_CRITICAL_SECTION();
    return result;
}
static int
__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context)
{
    CYTHON_UNUSED_VAR(context);
    if (unlikely(value == NULL || !PyUnicode_Check(value))) {
        PyErr_SetString(PyExc_TypeError,
                        "__qualname__ must be set to a string object");
        return -1;
    }
    Py_INCREF(value);
    __Pyx_BEGIN_CRITICAL_SECTION(op);
    __Pyx_Py_XDECREF_SET(op->func_qualname, value);
    __Pyx_END_CRITICAL_SECTION();
    return 0;
}
#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000
static PyObject *
__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context)
{
    CYTHON_UNUSED_VAR(context);
    if (unlikely(op->func_dict == NULL)) {
        op->func_dict = PyDict_New();
        if (unlikely(op->func_dict == NULL))
            return NULL;
    }
    Py_INCREF(op->func_dict);
    return op->func_dict;
}
#endif
static PyObject *
__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context)
{
    CYTHON_UNUSED_VAR(context);
    Py_INCREF(op->func_globals);
    return op->func_globals;
}
static PyObject *
__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context)
{
    CYTHON_UNUSED_VAR(op);
    CYTHON_UNUSED_VAR(context);
    Py_INCREF(Py_None);
    return Py_None;
}
static PyObject *
__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context)
{
    PyObject* result = (op->func_code) ? op->func_code : Py_None;
    CYTHON_UNUSED_VAR(context);
    Py_INCREF(result);
    return result;
}
static int
__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
    int result = 0;
    PyObject *res = op->defaults_getter((PyObject *) op);
    if (unlikely(!res))
        return -1;
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    op->defaults_tuple = PyTuple_GET_ITEM(res, 0);
    Py_INCREF(op->defaults_tuple);
    op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
    Py_INCREF(op->defaults_kwdict);
    #else
    op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0);
    if (unlikely(!op->defaults_tuple)) result = -1;
    else {
        op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1);
        if (unlikely(!op->defaults_kwdict)) result = -1;
    }
    #endif
    Py_DECREF(res);
    return result;
}
static int
__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
    CYTHON_UNUSED_VAR(context);
    if (!value) {
        value = Py_None;
    } else if (unlikely(value != Py_None && !PyTuple_Check(value))) {
        PyErr_SetString(PyExc_TypeError,
                        "__defaults__ must be set to a tuple object");
        return -1;
    }
    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not "
                 "currently affect the values used in function calls", 1);
    Py_INCREF(value);
    __Pyx_BEGIN_CRITICAL_SECTION(op);
    __Pyx_Py_XDECREF_SET(op->defaults_tuple, value);
    __Pyx_END_CRITICAL_SECTION();
    return 0;
}
static PyObject *
__Pyx_CyFunction_get_defaults_locked(__pyx_CyFunctionObject *op) {
    PyObject* result = op->defaults_tuple;
    if (unlikely(!result)) {
        if (op->defaults_getter) {
            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
            result = op->defaults_tuple;
        } else {
            result = Py_None;
        }
    }
    Py_INCREF(result);
    return result;
}
static PyObject *
__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) {
    PyObject* result = NULL;
    CYTHON_UNUSED_VAR(context);
    __Pyx_BEGIN_CRITICAL_SECTION(op);
    result = __Pyx_CyFunction_get_defaults_locked(op);
    __Pyx_END_CRITICAL_SECTION();
    return result;
}
static int
__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
    CYTHON_UNUSED_VAR(context);
    if (!value) {
        value = Py_None;
    } else if (unlikely(value != Py_None && !PyDict_Check(value))) {
        PyErr_SetString(PyExc_TypeError,
                        "__kwdefaults__ must be set to a dict object");
        return -1;
    }
    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not "
                 "currently affect the values used in function calls", 1);
    Py_INCREF(value);
    __Pyx_BEGIN_CRITICAL_SECTION(op);
    __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value);
    __Pyx_END_CRITICAL_SECTION();
    return 0;
}
static PyObject *
__Pyx_CyFunction_get_kwdefaults_locked(__pyx_CyFunctionObject *op) {
    PyObject* result = op->defaults_kwdict;
    if (unlikely(!result)) {
        if (op->defaults_getter) {
            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
            result = op->defaults_kwdict;
        } else {
            result = Py_None;
        }
    }
    Py_INCREF(result);
    return result;
}
static PyObject *
__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) {
    PyObject* result;
    CYTHON_UNUSED_VAR(context);
    __Pyx_BEGIN_CRITICAL_SECTION(op);
    result = __Pyx_CyFunction_get_kwdefaults_locked(op);
    __Pyx_END_CRITICAL_SECTION();
    return result;
}
static int
__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
    CYTHON_UNUSED_VAR(context);
    if (!value || value == Py_None) {
        value = NULL;
    } else if (unlikely(!PyDict_Check(value))) {
        PyErr_SetString(PyExc_TypeError,
                        "__annotations__ must be set to a dict object");
        return -1;
    }
    Py_XINCREF(value);
    __Pyx_BEGIN_CRITICAL_SECTION(op);
    __Pyx_Py_XDECREF_SET(op->func_annotations, value);
    __Pyx_END_CRITICAL_SECTION();
    return 0;
}
static PyObject *
__Pyx_CyFunction_get_annotations_locked(__pyx_CyFunctionObject *op) {
    PyObject* result = op->func_annotations;
    if (unlikely(!result)) {
        result = PyDict_New();
        if (unlikely(!result)) return NULL;
        op->func_annotations = result;
    }
    Py_INCREF(result);
    return result;
}
static PyObject *
__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) {
    PyObject *result;
    CYTHON_UNUSED_VAR(context);
    __Pyx_BEGIN_CRITICAL_SECTION(op);
    result = __Pyx_CyFunction_get_annotations_locked(op);
    __Pyx_END_CRITICAL_SECTION();
    return result;
}
static PyObject *
__Pyx_CyFunction_get_is_coroutine_value(__pyx_CyFunctionObject *op) {
    int is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE;
    if (is_coroutine) {
        PyObject *is_coroutine_value, *module, *fromlist, *marker = __pyx_mstate_global->__pyx_n_u_is_coroutine;
        fromlist = PyList_New(1);
        if (unlikely(!fromlist)) return NULL;
        Py_INCREF(marker);
#if CYTHON_ASSUME_SAFE_MACROS
        PyList_SET_ITEM(fromlist, 0, marker);
#else
        if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) {
            Py_DECREF(marker);
            Py_DECREF(fromlist);
            return NULL;
        }
#endif
        module = PyImport_ImportModuleLevelObject(__pyx_mstate_global->__pyx_n_u_asyncio_coroutines, NULL, NULL, fromlist, 0);
        Py_DECREF(fromlist);
        if (unlikely(!module)) goto ignore;
        is_coroutine_value = __Pyx_PyObject_GetAttrStr(module, marker);
        Py_DECREF(module);
        if (likely(is_coroutine_value)) {
            return is_coroutine_value;
        }
ignore:
        PyErr_Clear();
    }
    return __Pyx_PyBool_FromLong(is_coroutine);
}
static PyObject *
__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) {
    PyObject *result;
    CYTHON_UNUSED_VAR(context);
    if (op->func_is_coroutine) {
        return __Pyx_NewRef(op->func_is_coroutine);
    }
    result = __Pyx_CyFunction_get_is_coroutine_value(op);
    if (unlikely(!result))
        return NULL;
    __Pyx_BEGIN_CRITICAL_SECTION(op);
    if (op->func_is_coroutine) {
        Py_DECREF(result);
        result = __Pyx_NewRef(op->func_is_coroutine);
    } else {
        op->func_is_coroutine = __Pyx_NewRef(result);
    }
    __Pyx_END_CRITICAL_SECTION();
    return result;
}
static void __Pyx_CyFunction_raise_argument_count_error(__pyx_CyFunctionObject *func, const char* message, Py_ssize_t size) {
#if CYTHON_COMPILING_IN_LIMITED_API
    PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL);
    if (!py_name) return;
    PyErr_Format(PyExc_TypeError,
        "%.200S() %s (%" CYTHON_FORMAT_SSIZE_T "d given)",
        py_name, message, size);
    Py_DECREF(py_name);
#else
    const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name;
    PyErr_Format(PyExc_TypeError,
        "%.200s() %s (%" CYTHON_FORMAT_SSIZE_T "d given)",
        name, message, size);
#endif
}
static void __Pyx_CyFunction_raise_type_error(__pyx_CyFunctionObject *func, const char* message) {
#if CYTHON_COMPILING_IN_LIMITED_API
    PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL);
    if (!py_name) return;
    PyErr_Format(PyExc_TypeError,
        "%.200S() %s",
        py_name, message);
    Py_DECREF(py_name);
#else
    const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name;
    PyErr_Format(PyExc_TypeError,
        "%.200s() %s",
        name, message);
#endif
}
#if CYTHON_COMPILING_IN_LIMITED_API
static PyObject *
__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) {
    CYTHON_UNUSED_VAR(context);
    return PyObject_GetAttrString(op->func, "__module__");
}
static int
__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
    CYTHON_UNUSED_VAR(context);
    return PyObject_SetAttrString(op->func, "__module__", value);
}
#endif
static PyGetSetDef __pyx_CyFunction_getsets[] = {
    {"func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
    {"__doc__",  (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
    {"func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
    {"__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
    {"__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0},
#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000
    {"func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)PyObject_GenericSetDict, 0, 0},
    {"__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)PyObject_GenericSetDict, 0, 0},
#else
    {"func_dict", (getter)PyObject_GenericGetDict, (setter)PyObject_GenericSetDict, 0, 0},
    {"__dict__", (getter)PyObject_GenericGetDict, (setter)PyObject_GenericSetDict, 0, 0},
#endif
    {"func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
    {"__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
    {"func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
    {"__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
    {"func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
    {"__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
    {"func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
    {"__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
    {"__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0},
    {"__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0},
    {"_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0},
#if CYTHON_COMPILING_IN_LIMITED_API
    {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0},
#endif
    {0, 0, 0, 0, 0}
};
static PyMemberDef __pyx_CyFunction_members[] = {
#if !CYTHON_COMPILING_IN_LIMITED_API
    {"__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0},
#endif
#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API
    {"__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0},
#endif
#if CYTHON_METH_FASTCALL
#if CYTHON_COMPILING_IN_LIMITED_API
    {"__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0},
#else
    {"__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0},
#endif
#if CYTHON_COMPILING_IN_LIMITED_API
    {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0},
#else
    {"__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0},
#endif
#endif
    {0, 0, 0,  0, 0}
};
static PyObject *
__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args)
{
    PyObject *result = NULL;
    CYTHON_UNUSED_VAR(args);
    __Pyx_BEGIN_CRITICAL_SECTION(m);
    Py_INCREF(m->func_qualname);
    result = m->func_qualname;
    __Pyx_END_CRITICAL_SECTION();
    return result;
}
static PyMethodDef __pyx_CyFunction_methods[] = {
    {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0},
    {0, 0, 0, 0}
};
#if CYTHON_COMPILING_IN_LIMITED_API
#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist)
#else
#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist)
#endif
static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname,
                                       PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
#if !CYTHON_COMPILING_IN_LIMITED_API
    PyCFunctionObject *cf = (PyCFunctionObject*) op;
#endif
    if (unlikely(op == NULL))
        return NULL;
#if CYTHON_COMPILING_IN_LIMITED_API
    op->func = PyCFunction_NewEx(ml, (PyObject*)op, module);
    if (unlikely(!op->func)) return NULL;
#endif
    op->flags = flags;
    __Pyx_CyFunction_weakreflist(op) = NULL;
#if !CYTHON_COMPILING_IN_LIMITED_API
    cf->m_ml = ml;
    cf->m_self = (PyObject *) op;
#endif
    Py_XINCREF(closure);
    op->func_closure = closure;
#if !CYTHON_COMPILING_IN_LIMITED_API
    Py_XINCREF(module);
    cf->m_module = module;
#endif
#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API
    op->func_dict = NULL;
#endif
    op->func_name = NULL;
    Py_INCREF(qualname);
    op->func_qualname = qualname;
    op->func_doc = NULL;
#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
    op->func_classobj = NULL;
#else
    ((PyCMethodObject*)op)->mm_class = NULL;
#endif
    op->func_globals = globals;
    Py_INCREF(op->func_globals);
    Py_XINCREF(code);
    op->func_code = code;
    op->defaults = NULL;
    op->defaults_tuple = NULL;
    op->defaults_kwdict = NULL;
    op->defaults_getter = NULL;
    op->func_annotations = NULL;
    op->func_is_coroutine = NULL;
#if CYTHON_METH_FASTCALL
    switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) {
    case METH_NOARGS:
        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS;
        break;
    case METH_O:
        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O;
        break;
    case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD;
        break;
    case METH_FASTCALL | METH_KEYWORDS:
        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS;
        break;
    case METH_VARARGS | METH_KEYWORDS:
        __Pyx_CyFunction_func_vectorcall(op) = NULL;
        break;
    default:
        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
        Py_DECREF(op);
        return NULL;
    }
#endif
    return (PyObject *) op;
}
static int
__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
{
    Py_CLEAR(m->func_closure);
#if CYTHON_COMPILING_IN_LIMITED_API
    Py_CLEAR(m->func);
#else
    Py_CLEAR(((PyCFunctionObject*)m)->m_module);
#endif
#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API
    Py_CLEAR(m->func_dict);
#elif PY_VERSION_HEX < 0x030d0000
    _PyObject_ClearManagedDict((PyObject*)m);
#else
    PyObject_ClearManagedDict((PyObject*)m);
#endif
    Py_CLEAR(m->func_name);
    Py_CLEAR(m->func_qualname);
    Py_CLEAR(m->func_doc);
    Py_CLEAR(m->func_globals);
    Py_CLEAR(m->func_code);
#if !CYTHON_COMPILING_IN_LIMITED_API
#if PY_VERSION_HEX < 0x030900B1
    Py_CLEAR(__Pyx_CyFunction_GetClassObj(m));
#else
    {
        PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class;
        ((PyCMethodObject *) (m))->mm_class = NULL;
        Py_XDECREF(cls);
    }
#endif
#endif
    Py_CLEAR(m->defaults_tuple);
    Py_CLEAR(m->defaults_kwdict);
    Py_CLEAR(m->func_annotations);
    Py_CLEAR(m->func_is_coroutine);
    Py_CLEAR(m->defaults);
    return 0;
}
static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m)
{
    if (__Pyx_CyFunction_weakreflist(m) != NULL)
        PyObject_ClearWeakRefs((PyObject *) m);
    __Pyx_CyFunction_clear(m);
    __Pyx_PyHeapTypeObject_GC_Del(m);
}
static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
{
    PyObject_GC_UnTrack(m);
    __Pyx__CyFunction_dealloc(m);
}
static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg)
{
    {
        int e = __Pyx_call_type_traverse((PyObject*)m, 1, visit, arg);
        if (e) return e;
    }
    Py_VISIT(m->func_closure);
#if CYTHON_COMPILING_IN_LIMITED_API
    Py_VISIT(m->func);
#else
    Py_VISIT(((PyCFunctionObject*)m)->m_module);
#endif
#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API
    Py_VISIT(m->func_dict);
#else
    {
        int e =
#if PY_VERSION_HEX < 0x030d0000
            _PyObject_VisitManagedDict
#else
            PyObject_VisitManagedDict
#endif
                ((PyObject*)m, visit, arg);
        if (e != 0) return e;
    }
#endif
    __Pyx_VISIT_CONST(m->func_name);
    __Pyx_VISIT_CONST(m->func_qualname);
    Py_VISIT(m->func_doc);
    Py_VISIT(m->func_globals);
    __Pyx_VISIT_CONST(m->func_code);
#if !CYTHON_COMPILING_IN_LIMITED_API
    Py_VISIT(__Pyx_CyFunction_GetClassObj(m));
#endif
    Py_VISIT(m->defaults_tuple);
    Py_VISIT(m->defaults_kwdict);
    Py_VISIT(m->func_is_coroutine);
    Py_VISIT(m->defaults);
    return 0;
}
static PyObject*
__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op)
{
    PyObject *repr;
    __Pyx_BEGIN_CRITICAL_SECTION(op);
    repr = PyUnicode_FromFormat("<cyfunction %U at %p>",
                                op->func_qualname, (void *)op);
    __Pyx_END_CRITICAL_SECTION();
    return repr;
}
static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) {
#if CYTHON_COMPILING_IN_LIMITED_API
    PyObject *f = ((__pyx_CyFunctionObject*)func)->func;
    PyCFunction meth;
    int flags;
    meth = PyCFunction_GetFunction(f);
    if (unlikely(!meth)) return NULL;
    flags = PyCFunction_GetFlags(f);
    if (unlikely(flags < 0)) return NULL;
#else
    PyCFunctionObject* f = (PyCFunctionObject*)func;
    PyCFunction meth = f->m_ml->ml_meth;
    int flags = f->m_ml->ml_flags;
#endif
    Py_ssize_t size;
    switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) {
    case METH_VARARGS:
        if (likely(kw == NULL || PyDict_Size(kw) == 0))
            return (*meth)(self, arg);
        break;
    case METH_VARARGS | METH_KEYWORDS:
        return (*(PyCFunctionWithKeywords)(void(*)(void))meth)(self, arg, kw);
    case METH_NOARGS:
        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
#if CYTHON_ASSUME_SAFE_SIZE
            size = PyTuple_GET_SIZE(arg);
#else
            size = PyTuple_Size(arg);
            if (unlikely(size < 0)) return NULL;
#endif
            if (likely(size == 0))
                return (*meth)(self, NULL);
            __Pyx_CyFunction_raise_argument_count_error(
                (__pyx_CyFunctionObject*)func,
                "takes no arguments", size);
            return NULL;
        }
        break;
    case METH_O:
        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
#if CYTHON_ASSUME_SAFE_SIZE
            size = PyTuple_GET_SIZE(arg);
#else
            size = PyTuple_Size(arg);
            if (unlikely(size < 0)) return NULL;
#endif
            if (likely(size == 1)) {
                PyObject *result, *arg0;
                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
                arg0 = PyTuple_GET_ITEM(arg, 0);
                #else
                arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL;
                #endif
                result = (*meth)(self, arg0);
                #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
                Py_DECREF(arg0);
                #endif
                return result;
            }
            __Pyx_CyFunction_raise_argument_count_error(
                (__pyx_CyFunctionObject*)func,
                "takes exactly one argument", size);
            return NULL;
        }
        break;
    default:
        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
        return NULL;
    }
    __Pyx_CyFunction_raise_type_error(
        (__pyx_CyFunctionObject*)func, "takes no keyword arguments");
    return NULL;
}
static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) {
    PyObject *self, *result;
#if CYTHON_COMPILING_IN_LIMITED_API
    self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func);
    if (unlikely(!self) && PyErr_Occurred()) return NULL;
#else
    self = ((PyCFunctionObject*)func)->m_self;
#endif
    result = __Pyx_CyFunction_CallMethod(func, self, arg, kw);
    return result;
}
static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) {
    PyObject *result;
    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
#if CYTHON_METH_FASTCALL && CYTHON_VECTORCALL
     __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc);
    if (vc) {
#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE
        return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw);
#else
        (void) &__Pyx_PyVectorcall_FastCallDict;
        return PyVectorcall_Call(func, args, kw);
#endif
    }
#endif
    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
        Py_ssize_t argc;
        PyObject *new_args;
        PyObject *self;
#if CYTHON_ASSUME_SAFE_SIZE
        argc = PyTuple_GET_SIZE(args);
#else
        argc = PyTuple_Size(args);
        if (unlikely(argc < 0)) return NULL;
#endif
        new_args = PyTuple_GetSlice(args, 1, argc);
        if (unlikely(!new_args))
            return NULL;
        self = PyTuple_GetItem(args, 0);
        if (unlikely(!self)) {
            Py_DECREF(new_args);
            PyErr_Format(PyExc_TypeError,
                         "unbound method %.200S() needs an argument",
                         cyfunc->func_qualname);
            return NULL;
        }
        result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw);
        Py_DECREF(new_args);
    } else {
        result = __Pyx_CyFunction_Call(func, args, kw);
    }
    return result;
}
#if CYTHON_METH_FASTCALL && CYTHON_VECTORCALL
static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames)
{
    int ret = 0;
    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
        if (unlikely(nargs < 1)) {
            __Pyx_CyFunction_raise_type_error(
                cyfunc, "needs an argument");
            return -1;
        }
        ret = 1;
    }
    if (unlikely(kwnames) && unlikely(__Pyx_PyTuple_GET_SIZE(kwnames))) {
        __Pyx_CyFunction_raise_type_error(
            cyfunc, "takes no keyword arguments");
        return -1;
    }
    return ret;
}
static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
{
    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
    PyObject *self;
#if CYTHON_COMPILING_IN_LIMITED_API
    PyCFunction meth = PyCFunction_GetFunction(cyfunc->func);
    if (unlikely(!meth)) return NULL;
#else
    PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth;
#endif
    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
    case 1:
        self = args[0];
        args += 1;
        nargs -= 1;
        break;
    case 0:
#if CYTHON_COMPILING_IN_LIMITED_API
        self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func);
        if (unlikely(!self) && PyErr_Occurred()) return NULL;
#else
        self = ((PyCFunctionObject*)cyfunc)->m_self;
#endif
        break;
    default:
        return NULL;
    }
    if (unlikely(nargs != 0)) {
        __Pyx_CyFunction_raise_argument_count_error(
            cyfunc, "takes no arguments", nargs);
        return NULL;
    }
    return meth(self, NULL);
}
static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
{
    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
    PyObject *self;
#if CYTHON_COMPILING_IN_LIMITED_API
    PyCFunction meth = PyCFunction_GetFunction(cyfunc->func);
    if (unlikely(!meth)) return NULL;
#else
    PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth;
#endif
    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
    case 1:
        self = args[0];
        args += 1;
        nargs -= 1;
        break;
    case 0:
#if CYTHON_COMPILING_IN_LIMITED_API
        self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func);
        if (unlikely(!self) && PyErr_Occurred()) return NULL;
#else
        self = ((PyCFunctionObject*)cyfunc)->m_self;
#endif
        break;
    default:
        return NULL;
    }
    if (unlikely(nargs != 1)) {
        __Pyx_CyFunction_raise_argument_count_error(
            cyfunc, "takes exactly one argument", nargs);
        return NULL;
    }
    return meth(self, args[0]);
}
static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
{
    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
    PyObject *self;
#if CYTHON_COMPILING_IN_LIMITED_API
    PyCFunction meth = PyCFunction_GetFunction(cyfunc->func);
    if (unlikely(!meth)) return NULL;
#else
    PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth;
#endif
    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
    case 1:
        self = args[0];
        args += 1;
        nargs -= 1;
        break;
    case 0:
#if CYTHON_COMPILING_IN_LIMITED_API
        self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func);
        if (unlikely(!self) && PyErr_Occurred()) return NULL;
#else
        self = ((PyCFunctionObject*)cyfunc)->m_self;
#endif
        break;
    default:
        return NULL;
    }
    return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))meth)(self, args, nargs, kwnames);
}
static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
{
    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
    PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc);
    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
    PyObject *self;
#if CYTHON_COMPILING_IN_LIMITED_API
    PyCFunction meth = PyCFunction_GetFunction(cyfunc->func);
    if (unlikely(!meth)) return NULL;
#else
    PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth;
#endif
    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
    case 1:
        self = args[0];
        args += 1;
        nargs -= 1;
        break;
    case 0:
#if CYTHON_COMPILING_IN_LIMITED_API
        self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func);
        if (unlikely(!self) && PyErr_Occurred()) return NULL;
#else
        self = ((PyCFunctionObject*)cyfunc)->m_self;
#endif
        break;
    default:
        return NULL;
    }
    #if PY_VERSION_HEX < 0x030e00A6
    size_t nargs_value = (size_t) nargs;
    #else
    Py_ssize_t nargs_value = nargs;
    #endif
    return ((__Pyx_PyCMethod)(void(*)(void))meth)(self, cls, args, nargs_value, kwnames);
}
#endif
static PyType_Slot __pyx_CyFunctionType_slots[] = {
    {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc},
    {Py_tp_repr, (void *)__Pyx_CyFunction_repr},
    {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod},
    {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse},
    {Py_tp_clear, (void *)__Pyx_CyFunction_clear},
    {Py_tp_methods, (void *)__pyx_CyFunction_methods},
    {Py_tp_members, (void *)__pyx_CyFunction_members},
    {Py_tp_getset, (void *)__pyx_CyFunction_getsets},
    {Py_tp_descr_get, (void *)__Pyx_PyMethod_New},
    {0, 0},
};
static PyType_Spec __pyx_CyFunctionType_spec = {
    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
    sizeof(__pyx_CyFunctionObject),
    0,
#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
    Py_TPFLAGS_METHOD_DESCRIPTOR |
#endif
#if CYTHON_METH_FASTCALL
#if defined(Py_TPFLAGS_HAVE_VECTORCALL)
    Py_TPFLAGS_HAVE_VECTORCALL |
#elif defined(_Py_TPFLAGS_HAVE_VECTORCALL)
    _Py_TPFLAGS_HAVE_VECTORCALL |
#endif
#endif // CYTHON_METH_FASTCALL
#if PY_VERSION_HEX >= 0x030C0000 && !CYTHON_COMPILING_IN_LIMITED_API
    Py_TPFLAGS_MANAGED_DICT |
#endif
    Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION |
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
    __pyx_CyFunctionType_slots
};
static int __pyx_CyFunction_init(PyObject *module) {
    __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module);
    mstate->__pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(
        mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_CyFunctionType_spec, NULL);
    if (unlikely(mstate->__pyx_CyFunctionType == NULL)) {
        return -1;
    }
    return 0;
}
static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, PyTypeObject *defaults_type) {
    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
    m->defaults = PyObject_CallObject((PyObject*)defaults_type, NULL); // _PyObject_New(defaults_type);
    if (unlikely(!m->defaults))
        return NULL;
    return m->defaults;
}
static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) {
    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
    m->defaults_tuple = tuple;
    Py_INCREF(tuple);
}
static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) {
    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
    m->defaults_kwdict = dict;
    Py_INCREF(dict);
}
static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) {
    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
    m->func_annotations = dict;
    Py_INCREF(dict);
}

/* CythonFunction */
static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname,
                                      PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
    PyObject *op = __Pyx_CyFunction_Init(
        PyObject_GC_New(__pyx_CyFunctionObject, __pyx_mstate_global->__pyx_CyFunctionType),
        ml, flags, qualname, closure, module, globals, code
    );
    if (likely(op)) {
        PyObject_GC_Track(op);
    }
    return op;
}

/* CLineInTraceback (used by AddTraceback) */
#if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME
#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000
#define __Pyx_PyProbablyModule_GetDict(o) __Pyx_XNewRef(PyModule_GetDict(o))
#elif !CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
#define __Pyx_PyProbablyModule_GetDict(o) PyObject_GenericGetDict(o, NULL);
#else
PyObject* __Pyx_PyProbablyModule_GetDict(PyObject *o) {
    PyObject **dict_ptr = _PyObject_GetDictPtr(o);
    return dict_ptr ? __Pyx_XNewRef(*dict_ptr) : NULL;
}
#endif
static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) {
    PyObject *use_cline = NULL;
    PyObject *ptype, *pvalue, *ptraceback;
    PyObject *cython_runtime_dict;
    CYTHON_MAYBE_UNUSED_VAR(tstate);
    if (unlikely(!__pyx_mstate_global->__pyx_cython_runtime)) {
        return c_line;
    }
    __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback);
    cython_runtime_dict = __Pyx_PyProbablyModule_GetDict(__pyx_mstate_global->__pyx_cython_runtime);
    if (likely(cython_runtime_dict)) {
        __PYX_PY_DICT_LOOKUP_IF_MODIFIED(
            use_cline, cython_runtime_dict,
            __Pyx_PyDict_SetDefault(cython_runtime_dict, __pyx_mstate_global->__pyx_n_u_cline_in_traceback, Py_False))
    }
    if (use_cline == NULL || use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) {
        c_line = 0;
    }
    Py_XDECREF(use_cline);
    Py_XDECREF(cython_runtime_dict);
    __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback);
    return c_line;
}
#endif

/* CodeObjectCache (used by AddTraceback) */
static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
    int start = 0, mid = 0, end = count - 1;
    if (end >= 0 && code_line > entries[end].code_line) {
        return count;
    }
    while (start < end) {
        mid = start + (end - start) / 2;
        if (code_line < entries[mid].code_line) {
            end = mid;
        } else if (code_line > entries[mid].code_line) {
             start = mid + 1;
        } else {
            return mid;
        }
    }
    if (code_line <= entries[mid].code_line) {
        return mid;
    } else {
        return mid + 1;
    }
}
static __Pyx_CachedCodeObjectType *__pyx__find_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line) {
    __Pyx_CachedCodeObjectType* code_object;
    int pos;
    if (unlikely(!code_line) || unlikely(!code_cache->entries)) {
        return NULL;
    }
    pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line);
    if (unlikely(pos >= code_cache->count) || unlikely(code_cache->entries[pos].code_line != code_line)) {
        return NULL;
    }
    code_object = code_cache->entries[pos].code_object;
    Py_INCREF(code_object);
    return code_object;
}
static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line) {
#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS
    (void)__pyx__find_code_object;
    return NULL; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just miss.
#else
    struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache;
#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
    __pyx_nonatomic_int_type old_count = __pyx_atomic_incr_acq_rel(&code_cache->accessor_count);
    if (old_count < 0) {
        __pyx_atomic_decr_acq_rel(&code_cache->accessor_count);
        return NULL;
    }
#endif
    __Pyx_CachedCodeObjectType *result = __pyx__find_code_object(code_cache, code_line);
#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
    __pyx_atomic_decr_acq_rel(&code_cache->accessor_count);
#endif
    return result;
#endif
}
static void __pyx__insert_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line, __Pyx_CachedCodeObjectType* code_object)
{
    int pos, i;
    __Pyx_CodeObjectCacheEntry* entries = code_cache->entries;
    if (unlikely(!code_line)) {
        return;
    }
    if (unlikely(!entries)) {
        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry));
        if (likely(entries)) {
            code_cache->entries = entries;
            code_cache->max_count = 64;
            code_cache->count = 1;
            entries[0].code_line = code_line;
            entries[0].code_object = code_object;
            Py_INCREF(code_object);
        }
        return;
    }
    pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line);
    if ((pos < code_cache->count) && unlikely(code_cache->entries[pos].code_line == code_line)) {
        __Pyx_CachedCodeObjectType* tmp = entries[pos].code_object;
        entries[pos].code_object = code_object;
        Py_INCREF(code_object);
        Py_DECREF(tmp);
        return;
    }
    if (code_cache->count == code_cache->max_count) {
        int new_max = code_cache->max_count + 64;
        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc(
            code_cache->entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry));
        if (unlikely(!entries)) {
            return;
        }
        code_cache->entries = entries;
        code_cache->max_count = new_max;
    }
    for (i=code_cache->count; i>pos; i--) {
        entries[i] = entries[i-1];
    }
    entries[pos].code_line = code_line;
    entries[pos].code_object = code_object;
    code_cache->count++;
    Py_INCREF(code_object);
}
static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object) {
#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS
    (void)__pyx__insert_code_object;
    return; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just fail.
#else
    struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache;
#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
    __pyx_nonatomic_int_type expected = 0;
    if (!__pyx_atomic_int_cmp_exchange(&code_cache->accessor_count, &expected, INT_MIN)) {
        return;
    }
#endif
    __pyx__insert_code_object(code_cache, code_line, code_object);
#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
    __pyx_atomic_sub(&code_cache->accessor_count, INT_MIN);
#endif
#endif
}

/* AddTraceback */
#include "compile.h"
#include "frameobject.h"
#include "traceback.h"
#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API && !defined(PYPY_VERSION)
  #ifndef Py_BUILD_CORE
    #define Py_BUILD_CORE 1
  #endif
  #include "internal/pycore_frame.h"
#endif
#if CYTHON_COMPILING_IN_LIMITED_API
static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict,
                                                       PyObject *firstlineno, PyObject *name) {
    PyObject *replace = NULL;
    if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL;
    if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL;
    replace = PyObject_GetAttrString(code, "replace");
    if (likely(replace)) {
        PyObject *result = PyObject_Call(replace, __pyx_mstate_global->__pyx_empty_tuple, scratch_dict);
        Py_DECREF(replace);
        return result;
    }
    PyErr_Clear();
    return NULL;
}
static void __Pyx_AddTraceback(const char *funcname, int c_line,
                               int py_line, const char *filename) {
    PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL;
    PyObject *replace = NULL, *getframe = NULL, *frame = NULL;
    PyObject *exc_type, *exc_value, *exc_traceback;
    int success = 0;
    if (c_line) {
        c_line = __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line);
    }
    PyErr_Fetch(&exc_type, &exc_value, &exc_traceback);
    code_object = __pyx_find_code_object(c_line ? -c_line : py_line);
    if (!code_object) {
        code_object = Py_CompileString("_getframe()", filename, Py_eval_input);
        if (unlikely(!code_object)) goto bad;
        py_py_line = PyLong_FromLong(py_line);
        if (unlikely(!py_py_line)) goto bad;
        if (c_line) {
            py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
        } else {
            py_funcname = PyUnicode_FromString(funcname);
        }
        if (unlikely(!py_funcname)) goto bad;
        dict = PyDict_New();
        if (unlikely(!dict)) goto bad;
        {
            PyObject *old_code_object = code_object;
            code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname);
            Py_DECREF(old_code_object);
        }
        if (unlikely(!code_object)) goto bad;
        __pyx_insert_code_object(c_line ? -c_line : py_line, code_object);
    } else {
        dict = PyDict_New();
    }
    getframe = PySys_GetObject("_getframe");
    if (unlikely(!getframe)) goto bad;
    if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad;
    frame = PyEval_EvalCode(code_object, dict, dict);
    if (unlikely(!frame) || frame == Py_None) goto bad;
    success = 1;
  bad:
    PyErr_Restore(exc_type, exc_value, exc_traceback);
    Py_XDECREF(code_object);
    Py_XDECREF(py_py_line);
    Py_XDECREF(py_funcname);
    Py_XDECREF(dict);
    Py_XDECREF(replace);
    if (success) {
        PyTraceBack_Here(
            (struct _frame*)frame);
    }
    Py_XDECREF(frame);
}
#else
static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
            const char *funcname, int c_line,
            int py_line, const char *filename) {
    PyCodeObject *py_code = NULL;
    PyObject *py_funcname = NULL;
    if (c_line) {
        py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
        if (!py_funcname) goto bad;
        funcname = PyUnicode_AsUTF8(py_funcname);
        if (!funcname) goto bad;
    }
    py_code = PyCode_NewEmpty(filename, funcname, py_line);
    Py_XDECREF(py_funcname);
    return py_code;
bad:
    Py_XDECREF(py_funcname);
    return NULL;
}
static void __Pyx_AddTraceback(const char *funcname, int c_line,
                               int py_line, const char *filename) {
    PyCodeObject *py_code = 0;
    PyFrameObject *py_frame = 0;
    PyThreadState *tstate = __Pyx_PyThreadState_Current;
    PyObject *ptype, *pvalue, *ptraceback;
    if (c_line) {
        c_line = __Pyx_CLineForTraceback(tstate, c_line);
    }
    py_code = __pyx_find_code_object(c_line ? -c_line : py_line);
    if (!py_code) {
        __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback);
        py_code = __Pyx_CreateCodeObjectForTraceback(
            funcname, c_line, py_line, filename);
        if (!py_code) {
            /* If the code object creation fails, then we should clear the
               fetched exception references and propagate the new exception */
            Py_XDECREF(ptype);
            Py_XDECREF(pvalue);
            Py_XDECREF(ptraceback);
            goto bad;
        }
        __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback);
        __pyx_insert_code_object(c_line ? -c_line : py_line, py_code);
    }
    py_frame = PyFrame_New(
        tstate,            /*PyThreadState *tstate,*/
        py_code,           /*PyCodeObject *code,*/
        __pyx_mstate_global->__pyx_d,    /*PyObject *globals,*/
        0                  /*PyObject *locals*/
    );
    if (!py_frame) goto bad;
    __Pyx_PyFrame_SetLineNumber(py_frame, py_line);
    PyTraceBack_Here(py_frame);
bad:
    Py_XDECREF(py_code);
    Py_XDECREF(py_frame);
}
#endif

/* FormatTypeName */
#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000
static __Pyx_TypeName
__Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp)
{
    PyObject *module = NULL, *name = NULL, *result = NULL;
    #if __PYX_LIMITED_VERSION_HEX < 0x030b0000
    name = __Pyx_PyObject_GetAttrStr((PyObject *)tp,
                                               __pyx_mstate_global->__pyx_n_u_qualname);
    #else
    name = PyType_GetQualName(tp);
    #endif
    if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) goto bad;
    module = __Pyx_PyObject_GetAttrStr((PyObject *)tp,
                                               __pyx_mstate_global->__pyx_n_u_module);
    if (unlikely(module == NULL) || unlikely(!PyUnicode_Check(module))) goto bad;
    if (PyUnicode_CompareWithASCIIString(module, "builtins") == 0) {
        result = name;
        name = NULL;
        goto done;
    }
    result = PyUnicode_FromFormat("%U.%U", module, name);
    if (unlikely(result == NULL)) goto bad;
  done:
    Py_XDECREF(name);
    Py_XDECREF(module);
    return result;
  bad:
    PyErr_Clear();
    if (name) {
        result = name;
        name = NULL;
    } else {
        result = __Pyx_NewRef(__pyx_mstate_global->__pyx_kp_u__3);
    }
    goto done;
}
#endif

/* PyObjectVectorCallKwBuilder (used by CIntToPy) */
#if CYTHON_VECTORCALL
static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) {
    (void)__Pyx_PyObject_FastCallDict;
    if (__Pyx_PyTuple_SET_ITEM(builder, n, key) != (0)) return -1;
    Py_INCREF(key);
    args[n] = value;
    return 0;
}
CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) {
    (void)__Pyx_VectorcallBuilder_AddArgStr;
    if (unlikely(!PyUnicode_Check(key))) {
        PyErr_SetString(PyExc_TypeError, "keywords must be strings");
        return -1;
    }
    return __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n);
}
static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n) {
    PyObject *pyKey = PyUnicode_FromString(key);
    if (!pyKey) return -1;
    return __Pyx_VectorcallBuilder_AddArg(pyKey, value, builder, args, n);
}
#else // CYTHON_VECTORCALL
CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, CYTHON_UNUSED PyObject **args, CYTHON_UNUSED int n) {
    if (unlikely(!PyUnicode_Check(key))) {
        PyErr_SetString(PyExc_TypeError, "keywords must be strings");
        return -1;
    }
    return PyDict_SetItem(builder, key, value);
}
#endif

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const long neg_one = (long) -1, const_zero = (long) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(long) < sizeof(long)) {
            return PyLong_FromLong((long) value);
        } else if (sizeof(long) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#if !CYTHON_COMPILING_IN_PYPY
        } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(long) <= sizeof(long)) {
            return PyLong_FromLong((long) value);
        } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
        }
    }
    {
        unsigned char *bytes = (unsigned char *)&value;
#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
        if (is_unsigned) {
            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
        } else {
            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
        }
#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
        int one = 1; int little = (int)*(unsigned char *)&one;
        return _PyLong_FromByteArray(bytes, sizeof(long),
                                     little, !is_unsigned);
#else
        int one = 1; int little = (int)*(unsigned char *)&one;
        PyObject *from_bytes, *result = NULL, *kwds = NULL;
        PyObject *py_bytes = NULL, *order_str = NULL;
        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
        if (!from_bytes) return NULL;
        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long));
        if (!py_bytes) goto limited_bad;
        order_str = PyUnicode_FromString(little ? "little" : "big");
        if (!order_str) goto limited_bad;
        {
            PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str };
            if (!is_unsigned) {
                kwds = __Pyx_MakeVectorcallBuilderKwds(1);
                if (!kwds) goto limited_bad;
                if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad;
            }
            result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds);
        }
        limited_bad:
        Py_XDECREF(kwds);
        Py_XDECREF(order_str);
        Py_XDECREF(py_bytes);
        Py_XDECREF(from_bytes);
        return result;
#endif
    }
}

/* CIntFromPyVerify (used by CIntFromPy) */
#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0)
#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\
    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1)
#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\
    {\
        func_type value = func_value;\
        if (sizeof(target_type) < sizeof(func_type)) {\
            if (unlikely(value != (func_type) (target_type) value)) {\
                func_type zero = 0;\
                if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\
                    return (target_type) -1;\
                if (is_unsigned && unlikely(value < zero))\
                    goto raise_neg_overflow;\
                else\
                    goto raise_overflow;\
            }\
        }\
        return (target_type) value;\
    }

/* CIntFromPy */
static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const long neg_one = (long) -1, const_zero = (long) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (unlikely(!PyLong_Check(x))) {
        long val;
        PyObject *tmp = __Pyx_PyNumber_Long(x);
        if (!tmp) return (long) -1;
        val = __Pyx_PyLong_As_long(tmp);
        Py_DECREF(tmp);
        return val;
    }
    if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
            goto raise_neg_overflow;
        } else if (__Pyx_PyLong_IsCompact(x)) {
            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
        } else {
            const digit* digits = __Pyx_PyLong_Digits(x);
            assert(__Pyx_PyLong_DigitCount(x) > 1);
            switch (__Pyx_PyLong_DigitCount(x)) {
                case 2:
                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) {
                            return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) {
                            return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) {
                            return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                        }
                    }
                    break;
            }
        }
#endif
#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
        if (unlikely(Py_SIZE(x) < 0)) {
            goto raise_neg_overflow;
        }
#else
        {
            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
            if (unlikely(result < 0))
                return (long) -1;
            if (unlikely(result == 1))
                goto raise_neg_overflow;
        }
#endif
        if ((sizeof(long) <= sizeof(unsigned long))) {
            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
        } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
        }
    } else {
#if CYTHON_USE_PYLONG_INTERNALS
        if (__Pyx_PyLong_IsCompact(x)) {
            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
        } else {
            const digit* digits = __Pyx_PyLong_Digits(x);
            assert(__Pyx_PyLong_DigitCount(x) > 1);
            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                case -2:
                    if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                            return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                            return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                            return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                            return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                            return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                            return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
            }
        }
#endif
        if ((sizeof(long) <= sizeof(long))) {
            __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
        } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
        }
    }
    {
        long val;
        int ret = -1;
#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
        if (unlikely(bytes_copied == -1)) {
        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
            goto raise_overflow;
        } else {
            ret = 0;
        }
#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
        int one = 1; int is_little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&val;
        ret = _PyLong_AsByteArray((PyLongObject *)x,
                                    bytes, sizeof(val),
                                    is_little, !is_unsigned);
#else
        PyObject *v;
        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
        int bits, remaining_bits, is_negative = 0;
        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
        if (likely(PyLong_CheckExact(x))) {
            v = __Pyx_NewRef(x);
        } else {
            v = PyNumber_Long(x);
            if (unlikely(!v)) return (long) -1;
            assert(PyLong_CheckExact(v));
        }
        {
            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
            if (unlikely(result < 0)) {
                Py_DECREF(v);
                return (long) -1;
            }
            is_negative = result == 1;
        }
        if (is_unsigned && unlikely(is_negative)) {
            Py_DECREF(v);
            goto raise_neg_overflow;
        } else if (is_negative) {
            stepval = PyNumber_Invert(v);
            Py_DECREF(v);
            if (unlikely(!stepval))
                return (long) -1;
        } else {
            stepval = v;
        }
        v = NULL;
        val = (long) 0;
        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
        for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) {
            PyObject *tmp, *digit;
            long idigit;
            digit = PyNumber_And(stepval, mask);
            if (unlikely(!digit)) goto done;
            idigit = PyLong_AsLong(digit);
            Py_DECREF(digit);
            if (unlikely(idigit < 0)) goto done;
            val |= ((long) idigit) << bits;
            tmp = PyNumber_Rshift(stepval, shift);
            if (unlikely(!tmp)) goto done;
            Py_DECREF(stepval); stepval = tmp;
        }
        Py_DECREF(shift); shift = NULL;
        Py_DECREF(mask); mask = NULL;
        {
            long idigit = PyLong_AsLong(stepval);
            if (unlikely(idigit < 0)) goto done;
            remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1);
            if (unlikely(idigit >= (1L << remaining_bits)))
                goto raise_overflow;
            val |= ((long) idigit) << bits;
        }
        if (!is_unsigned) {
            if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1))))
                goto raise_overflow;
            if (is_negative)
                val = ~val;
        }
        ret = 0;
    done:
        Py_XDECREF(shift);
        Py_XDECREF(mask);
        Py_XDECREF(stepval);
#endif
        if (unlikely(ret))
            return (long) -1;
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to long");
    return (long) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to long");
    return (long) -1;
}

/* CIntFromPy */
static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const int neg_one = (int) -1, const_zero = (int) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (unlikely(!PyLong_Check(x))) {
        int val;
        PyObject *tmp = __Pyx_PyNumber_Long(x);
        if (!tmp) return (int) -1;
        val = __Pyx_PyLong_As_int(tmp);
        Py_DECREF(tmp);
        return val;
    }
    if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
            goto raise_neg_overflow;
        } else if (__Pyx_PyLong_IsCompact(x)) {
            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
        } else {
            const digit* digits = __Pyx_PyLong_Digits(x);
            assert(__Pyx_PyLong_DigitCount(x) > 1);
            switch (__Pyx_PyLong_DigitCount(x)) {
                case 2:
                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) {
                            return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) {
                            return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) {
                            return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                        }
                    }
                    break;
            }
        }
#endif
#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
        if (unlikely(Py_SIZE(x) < 0)) {
            goto raise_neg_overflow;
        }
#else
        {
            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
            if (unlikely(result < 0))
                return (int) -1;
            if (unlikely(result == 1))
                goto raise_neg_overflow;
        }
#endif
        if ((sizeof(int) <= sizeof(unsigned long))) {
            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
        } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
        }
    } else {
#if CYTHON_USE_PYLONG_INTERNALS
        if (__Pyx_PyLong_IsCompact(x)) {
            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
        } else {
            const digit* digits = __Pyx_PyLong_Digits(x);
            assert(__Pyx_PyLong_DigitCount(x) > 1);
            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                case -2:
                    if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                            return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                            return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                            return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                            return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                            return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                            return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
            }
        }
#endif
        if ((sizeof(int) <= sizeof(long))) {
            __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
        } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) {
            __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
        }
    }
    {
        int val;
        int ret = -1;
#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
        if (unlikely(bytes_copied == -1)) {
        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
            goto raise_overflow;
        } else {
            ret = 0;
        }
#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
        int one = 1; int is_little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&val;
        ret = _PyLong_AsByteArray((PyLongObject *)x,
                                    bytes, sizeof(val),
                                    is_little, !is_unsigned);
#else
        PyObject *v;
        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
        int bits, remaining_bits, is_negative = 0;
        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
        if (likely(PyLong_CheckExact(x))) {
            v = __Pyx_NewRef(x);
        } else {
            v = PyNumber_Long(x);
            if (unlikely(!v)) return (int) -1;
            assert(PyLong_CheckExact(v));
        }
        {
            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
            if (unlikely(result < 0)) {
                Py_DECREF(v);
                return (int) -1;
            }
            is_negative = result == 1;
        }
        if (is_unsigned && unlikely(is_negative)) {
            Py_DECREF(v);
            goto raise_neg_overflow;
        } else if (is_negative) {
            stepval = PyNumber_Invert(v);
            Py_DECREF(v);
            if (unlikely(!stepval))
                return (int) -1;
        } else {
            stepval = v;
        }
        v = NULL;
        val = (int) 0;
        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
        for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) {
            PyObject *tmp, *digit;
            long idigit;
            digit = PyNumber_And(stepval, mask);
            if (unlikely(!digit)) goto done;
            idigit = PyLong_AsLong(digit);
            Py_DECREF(digit);
            if (unlikely(idigit < 0)) goto done;
            val |= ((int) idigit) << bits;
            tmp = PyNumber_Rshift(stepval, shift);
            if (unlikely(!tmp)) goto done;
            Py_DECREF(stepval); stepval = tmp;
        }
        Py_DECREF(shift); shift = NULL;
        Py_DECREF(mask); mask = NULL;
        {
            long idigit = PyLong_AsLong(stepval);
            if (unlikely(idigit < 0)) goto done;
            remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1);
            if (unlikely(idigit >= (1L << remaining_bits)))
                goto raise_overflow;
            val |= ((int) idigit) << bits;
        }
        if (!is_unsigned) {
            if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1))))
                goto raise_overflow;
            if (is_negative)
                val = ~val;
        }
        ret = 0;
    done:
        Py_XDECREF(shift);
        Py_XDECREF(mask);
        Py_XDECREF(stepval);
#endif
        if (unlikely(ret))
            return (int) -1;
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to int");
    return (int) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to int");
    return (int) -1;
}

/* FastTypeChecks */
#if CYTHON_COMPILING_IN_CPYTHON
static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
    while (a) {
        a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*);
        if (a == b)
            return 1;
    }
    return b == &PyBaseObject_Type;
}
static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
    PyObject *mro;
    if (a == b) return 1;
    mro = a->tp_mro;
    if (likely(mro)) {
        Py_ssize_t i, n;
        n = PyTuple_GET_SIZE(mro);
        for (i = 0; i < n; i++) {
            if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b)
                return 1;
        }
        return 0;
    }
    return __Pyx_InBases(a, b);
}
static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) {
    PyObject *mro;
    if (cls == a || cls == b) return 1;
    mro = cls->tp_mro;
    if (likely(mro)) {
        Py_ssize_t i, n;
        n = PyTuple_GET_SIZE(mro);
        for (i = 0; i < n; i++) {
            PyObject *base = PyTuple_GET_ITEM(mro, i);
            if (base == (PyObject *)a || base == (PyObject *)b)
                return 1;
        }
        return 0;
    }
    return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b);
}
static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) {
    if (exc_type1) {
        return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2);
    } else {
        return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
    }
}
static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
    Py_ssize_t i, n;
    assert(PyExceptionClass_Check(exc_type));
    n = PyTuple_GET_SIZE(tuple);
    for (i=0; i<n; i++) {
        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
    }
    for (i=0; i<n; i++) {
        PyObject *t = PyTuple_GET_ITEM(tuple, i);
        if (likely(PyExceptionClass_Check(t))) {
            if (__Pyx_inner_PyErr_GivenExceptionMatches2(exc_type, NULL, t)) return 1;
        } else {
        }
    }
    return 0;
}
static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject* exc_type) {
    if (likely(err == exc_type)) return 1;
    if (likely(PyExceptionClass_Check(err))) {
        if (likely(PyExceptionClass_Check(exc_type))) {
            return __Pyx_inner_PyErr_GivenExceptionMatches2(err, NULL, exc_type);
        } else if (likely(PyTuple_Check(exc_type))) {
            return __Pyx_PyErr_GivenExceptionMatchesTuple(err, exc_type);
        } else {
        }
    }
    return PyErr_GivenExceptionMatches(err, exc_type);
}
static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *exc_type1, PyObject *exc_type2) {
    assert(PyExceptionClass_Check(exc_type1));
    assert(PyExceptionClass_Check(exc_type2));
    if (likely(err == exc_type1 || err == exc_type2)) return 1;
    if (likely(PyExceptionClass_Check(err))) {
        return __Pyx_inner_PyErr_GivenExceptionMatches2(err, exc_type1, exc_type2);
    }
    return (PyErr_GivenExceptionMatches(err, exc_type1) || PyErr_GivenExceptionMatches(err, exc_type2));
}
#endif

/* GetRuntimeVersion */
#if __PYX_LIMITED_VERSION_HEX < 0x030b0000
void __Pyx_init_runtime_version(void) {
    if (__Pyx_cached_runtime_version == 0) {
        const char* rt_version = Py_GetVersion();
        unsigned long version = 0;
        unsigned long factor = 0x01000000UL;
        unsigned int digit = 0;
        int i = 0;
        while (factor) {
            while ('0' <= rt_version[i] && rt_version[i] <= '9') {
                digit = digit * 10 + (unsigned int) (rt_version[i] - '0');
                ++i;
            }
            version += factor * digit;
            if (rt_version[i] != '.')
                break;
            digit = 0;
            factor >>= 8;
            ++i;
        }
        __Pyx_cached_runtime_version = version;
    }
}
#endif
static unsigned long __Pyx_get_runtime_version(void) {
#if __PYX_LIMITED_VERSION_HEX >= 0x030b0000
    return Py_Version & ~0xFFUL;
#else
    return __Pyx_cached_runtime_version;
#endif
}

/* CheckBinaryVersion */
static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) {
    const unsigned long MAJOR_MINOR = 0xFFFF0000UL;
    if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR))
        return 0;
    if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR)))
        return 1;
    {
        char message[200];
        PyOS_snprintf(message, sizeof(message),
                      "compile time Python version %d.%d "
                      "of module '%.100s' "
                      "%s "
                      "runtime version %d.%d",
                       (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF),
                       __Pyx_MODULE_NAME,
                       (allow_newer) ? "was newer than" : "does not match",
                       (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF)
       );
        return PyErr_WarnEx(NULL, message, 1);
    }
}

/* NewCodeObj */
#if CYTHON_COMPILING_IN_LIMITED_API
    static PyObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f,
                                       PyObject *code, PyObject *c, PyObject* n, PyObject *v,
                                       PyObject *fv, PyObject *cell, PyObject* fn,
                                       PyObject *name, int fline, PyObject *lnos) {
        PyObject *exception_table = NULL;
        PyObject *types_module=NULL, *code_type=NULL, *result=NULL;
        #if __PYX_LIMITED_VERSION_HEX < 0x030b0000
        PyObject *version_info;
        PyObject *py_minor_version = NULL;
        #endif
        long minor_version = 0;
        PyObject *type, *value, *traceback;
        PyErr_Fetch(&type, &value, &traceback);
        #if __PYX_LIMITED_VERSION_HEX >= 0x030b0000
        minor_version = 11;
        #else
        if (!(version_info = PySys_GetObject("version_info"))) goto end;
        if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end;
        minor_version = PyLong_AsLong(py_minor_version);
        Py_DECREF(py_minor_version);
        if (minor_version == -1 && PyErr_Occurred()) goto end;
        #endif
        if (!(types_module = PyImport_ImportModule("types"))) goto end;
        if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end;
        if (minor_version <= 7) {
            (void)p;
            result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOOO", a, k, l, s, f, code,
                          c, n, v, fn, name, fline, lnos, fv, cell);
        } else if (minor_version <= 10) {
            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOOO", a,p, k, l, s, f, code,
                          c, n, v, fn, name, fline, lnos, fv, cell);
        } else {
            if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end;
            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOOOO", a,p, k, l, s, f, code,
                          c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell);
        }
    end:
        Py_XDECREF(code_type);
        Py_XDECREF(exception_table);
        Py_XDECREF(types_module);
        if (type) {
            PyErr_Restore(type, value, traceback);
        }
        return result;
    }
#elif PY_VERSION_HEX >= 0x030B0000
  static PyCodeObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f,
                                         PyObject *code, PyObject *c, PyObject* n, PyObject *v,
                                         PyObject *fv, PyObject *cell, PyObject* fn,
                                         PyObject *name, int fline, PyObject *lnos) {
    PyCodeObject *result;
    result =
      #if PY_VERSION_HEX >= 0x030C0000
        PyUnstable_Code_NewWithPosOnlyArgs
      #else
        PyCode_NewWithPosOnlyArgs
      #endif
        (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, __pyx_mstate_global->__pyx_empty_bytes);
    #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030c00A1
    if (likely(result))
        result->_co_firsttraceable = 0;
    #endif
    return result;
  }
#elif !CYTHON_COMPILING_IN_PYPY
  #define __Pyx__PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
          PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
#else
  #define __Pyx__PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
          PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
#endif
static PyObject* __Pyx_PyCode_New(
        const __Pyx_PyCode_New_function_description descr,
        PyObject * const *varnames,
        PyObject *filename,
        PyObject *funcname,
        PyObject *line_table,
        PyObject *tuple_dedup_map
) {
    PyObject *code_obj = NULL, *varnames_tuple_dedup = NULL, *code_bytes = NULL;
    Py_ssize_t var_count = (Py_ssize_t) descr.nlocals;
    PyObject *varnames_tuple = PyTuple_New(var_count);
    if (unlikely(!varnames_tuple)) return NULL;
    for (Py_ssize_t i=0; i < var_count; i++) {
        Py_INCREF(varnames[i]);
        if (__Pyx_PyTuple_SET_ITEM(varnames_tuple, i, varnames[i]) != (0)) goto done;
    }
    #if CYTHON_COMPILING_IN_LIMITED_API
    varnames_tuple_dedup = PyDict_GetItem(tuple_dedup_map, varnames_tuple);
    if (!varnames_tuple_dedup) {
        if (unlikely(PyDict_SetItem(tuple_dedup_map, varnames_tuple, varnames_tuple) < 0)) goto done;
        varnames_tuple_dedup = varnames_tuple;
    }
    #else
    varnames_tuple_dedup = PyDict_SetDefault(tuple_dedup_map, varnames_tuple, varnames_tuple);
    if (unlikely(!varnames_tuple_dedup)) goto done;
    #endif
    #if CYTHON_AVOID_BORROWED_REFS
    Py_INCREF(varnames_tuple_dedup);
    #endif
    if (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table != NULL && !CYTHON_COMPILING_IN_GRAAL) {
        Py_ssize_t line_table_length = __Pyx_PyBytes_GET_SIZE(line_table);
        #if !CYTHON_ASSUME_SAFE_SIZE
        if (unlikely(line_table_length == -1)) goto done;
        #endif
        Py_ssize_t code_len = (line_table_length * 2 + 4) & ~3LL;
        code_bytes = PyBytes_FromStringAndSize(NULL, code_len);
        if (unlikely(!code_bytes)) goto done;
        char* c_code_bytes = PyBytes_AsString(code_bytes);
        if (unlikely(!c_code_bytes)) goto done;
        memset(c_code_bytes, 0, (size_t) code_len);
    }
    code_obj = (PyObject*) __Pyx__PyCode_New(
        (int) descr.argcount,
        (int) descr.num_posonly_args,
        (int) descr.num_kwonly_args,
        (int) descr.nlocals,
        0,
        (int) descr.flags,
        code_bytes ? code_bytes : __pyx_mstate_global->__pyx_empty_bytes,
        __pyx_mstate_global->__pyx_empty_tuple,
        __pyx_mstate_global->__pyx_empty_tuple,
        varnames_tuple_dedup,
        __pyx_mstate_global->__pyx_empty_tuple,
        __pyx_mstate_global->__pyx_empty_tuple,
        filename,
        funcname,
        (int) descr.first_line,
        (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table) ? line_table : __pyx_mstate_global->__pyx_empty_bytes
    );
done:
    Py_XDECREF(code_bytes);
    #if CYTHON_AVOID_BORROWED_REFS
    Py_XDECREF(varnames_tuple_dedup);
    #endif
    Py_DECREF(varnames_tuple);
    return code_obj;
}

/* DecompressString */
static PyObject *__Pyx_DecompressString(const char *s, Py_ssize_t length, int algo) {
    PyObject *module, *decompress, *compressed_bytes, *decompressed;
    const char* module_name = algo == 3 ? "compression.zstd" : algo == 2 ? "bz2" : "zlib";
    PyObject *methodname = PyUnicode_FromString("decompress");
    if (unlikely(!methodname)) return NULL;
    #if __PYX_LIMITED_VERSION_HEX >= 0x030e0000
    if (algo == 3) {
        PyObject *fromlist = Py_BuildValue("[O]", methodname);
        if (unlikely(!fromlist)) return NULL;
        module = PyImport_ImportModuleLevel("compression.zstd", NULL, NULL, fromlist, 0);
        Py_DECREF(fromlist);
    } else
    #endif
        module = PyImport_ImportModule(module_name);
    if (unlikely(!module)) goto import_failed;
    decompress = PyObject_GetAttr(module, methodname);
    if (unlikely(!decompress)) goto import_failed;
    {
        #ifdef __cplusplus
            char *memview_bytes = const_cast<char*>(s);
        #else
            #if defined(__clang__)
              #pragma clang diagnostic push
              #pragma clang diagnostic ignored "-Wcast-qual"
            #elif !defined(__INTEL_COMPILER) && defined(__GNUC__)
              #pragma GCC diagnostic push
              #pragma GCC diagnostic ignored "-Wcast-qual"
            #endif
            char *memview_bytes = (char*) s;
            #if defined(__clang__)
              #pragma clang diagnostic pop
            #elif !defined(__INTEL_COMPILER) && defined(__GNUC__)
              #pragma GCC diagnostic pop
            #endif
        #endif
        #if CYTHON_COMPILING_IN_LIMITED_API && !defined(PyBUF_READ)
        int memview_flags = 0x100;
        #else
        int memview_flags = PyBUF_READ;
        #endif
        compressed_bytes = PyMemoryView_FromMemory(memview_bytes, length, memview_flags);
    }
    if (unlikely(!compressed_bytes)) {
        Py_DECREF(decompress);
        goto bad;
    }
    decompressed = PyObject_CallFunctionObjArgs(decompress, compressed_bytes, NULL);
    Py_DECREF(compressed_bytes);
    Py_DECREF(decompress);
    Py_DECREF(module);
    Py_DECREF(methodname);
    return decompressed;
import_failed:
    PyErr_Format(PyExc_ImportError,
        "Failed to import '%.20s.decompress' - cannot initialise module strings. "
        "String compression was configured with the C macro 'CYTHON_COMPRESS_STRINGS=%d'.",
        module_name, algo);
bad:
    Py_XDECREF(module);
    Py_DECREF(methodname);
    return NULL;
}

#include <string.h>
static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) {
    size_t len = strlen(s);
    if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) {
        PyErr_SetString(PyExc_OverflowError, "byte string is too long");
        return -1;
    }
    return (Py_ssize_t) len;
}
static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
    if (unlikely(len < 0)) return NULL;
    return __Pyx_PyUnicode_FromStringAndSize(c_str, len);
}
static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) {
    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
    if (unlikely(len < 0)) return NULL;
    return PyByteArray_FromStringAndSize(c_str, len);
}
static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
    Py_ssize_t ignore;
    return __Pyx_PyObject_AsStringAndSize(o, &ignore);
}
#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_UTF8
static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
    if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL;
#if CYTHON_COMPILING_IN_LIMITED_API
    {
        const char* result;
        Py_ssize_t unicode_length;
        CYTHON_MAYBE_UNUSED_VAR(unicode_length); // only for __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
        #if __PYX_LIMITED_VERSION_HEX < 0x030A0000
        if (unlikely(PyArg_Parse(o, "s#", &result, length) < 0)) return NULL;
        #else
        result = PyUnicode_AsUTF8AndSize(o, length);
        #endif
        #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
        unicode_length = PyUnicode_GetLength(o);
        if (unlikely(unicode_length < 0)) return NULL;
        if (unlikely(unicode_length != *length)) {
            PyUnicode_AsASCIIString(o);
            return NULL;
        }
        #endif
        return result;
    }
#else
#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
    if (likely(PyUnicode_IS_ASCII(o))) {
        *length = PyUnicode_GET_LENGTH(o);
        return PyUnicode_AsUTF8(o);
    } else {
        PyUnicode_AsASCIIString(o);
        return NULL;
    }
#else
    return PyUnicode_AsUTF8AndSize(o, length);
#endif
#endif
}
#endif
static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_UTF8
    if (PyUnicode_Check(o)) {
        return __Pyx_PyUnicode_AsStringAndSize(o, length);
    } else
#endif
    if (PyByteArray_Check(o)) {
#if (CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) || (CYTHON_COMPILING_IN_PYPY && (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)))
        *length = PyByteArray_GET_SIZE(o);
        return PyByteArray_AS_STRING(o);
#else
        *length = PyByteArray_Size(o);
        if (*length == -1) return NULL;
        return PyByteArray_AsString(o);
#endif
    } else
    {
        char* result;
        int r = PyBytes_AsStringAndSize(o, &result, length);
        if (unlikely(r < 0)) {
            return NULL;
        } else {
            return result;
        }
    }
}
static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
   int is_true = x == Py_True;
   if (is_true | (x == Py_False) | (x == Py_None)) return is_true;
   else return PyObject_IsTrue(x);
}
static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
    int retval;
    if (unlikely(!x)) return -1;
    retval = __Pyx_PyObject_IsTrue(x);
    Py_DECREF(x);
    return retval;
}
static PyObject* __Pyx_PyNumber_LongWrongResultType(PyObject* result) {
    __Pyx_TypeName result_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(result));
    if (PyLong_Check(result)) {
        if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
                "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ").  "
                "The ability to return an instance of a strict subclass of int is deprecated, "
                "and may be removed in a future version of Python.",
                result_type_name)) {
            __Pyx_DECREF_TypeName(result_type_name);
            Py_DECREF(result);
            return NULL;
        }
        __Pyx_DECREF_TypeName(result_type_name);
        return result;
    }
    PyErr_Format(PyExc_TypeError,
                 "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ")",
                 result_type_name);
    __Pyx_DECREF_TypeName(result_type_name);
    Py_DECREF(result);
    return NULL;
}
static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(PyObject* x) {
#if CYTHON_USE_TYPE_SLOTS
  PyNumberMethods *m;
#endif
  PyObject *res = NULL;
  if (likely(PyLong_Check(x)))
      return __Pyx_NewRef(x);
#if CYTHON_USE_TYPE_SLOTS
  m = Py_TYPE(x)->tp_as_number;
  if (likely(m && m->nb_int)) {
      res = m->nb_int(x);
  }
#else
  if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) {
      res = PyNumber_Long(x);
  }
#endif
  if (likely(res)) {
      if (unlikely(!PyLong_CheckExact(res))) {
          return __Pyx_PyNumber_LongWrongResultType(res);
      }
  }
  else if (!PyErr_Occurred()) {
      PyErr_SetString(PyExc_TypeError,
                      "an integer is required");
  }
  return res;
}
static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
  Py_ssize_t ival;
  PyObject *x;
  if (likely(PyLong_CheckExact(b))) {
    #if CYTHON_USE_PYLONG_INTERNALS
    if (likely(__Pyx_PyLong_IsCompact(b))) {
        return __Pyx_PyLong_CompactValue(b);
    } else {
      const digit* digits = __Pyx_PyLong_Digits(b);
      const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b);
      switch (size) {
         case 2:
           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
             return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case -2:
           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
             return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case 3:
           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
             return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case -3:
           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
             return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case 4:
           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
             return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case -4:
           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
             return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
      }
    }
    #endif
    return PyLong_AsSsize_t(b);
  }
  x = PyNumber_Index(b);
  if (!x) return -1;
  ival = PyLong_AsSsize_t(x);
  Py_DECREF(x);
  return ival;
}
static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) {
  if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) {
    return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o);
  } else {
    Py_ssize_t ival;
    PyObject *x;
    x = PyNumber_Index(o);
    if (!x) return -1;
    ival = PyLong_AsLong(x);
    Py_DECREF(x);
    return ival;
  }
}
static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b) {
    CYTHON_UNUSED_VAR(b);
    return __Pyx_NewRef(Py_None);
}
static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) {
  return __Pyx_NewRef(b ? Py_True: Py_False);
}
static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t ival) {
    return PyLong_FromSize_t(ival);
}


/* MultiPhaseInitModuleState */
#if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE
#ifndef CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
#if (CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX >= 0x030C0000)
  #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 1
#else
  #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 0
#endif
#endif
#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE && !CYTHON_ATOMICS
#error "Module state with PEP489 requires atomics. Currently that's one of\
 C11, C++11, gcc atomic intrinsics or MSVC atomic intrinsics"
#endif
#if !CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
#define __Pyx_ModuleStateLookup_Lock()
#define __Pyx_ModuleStateLookup_Unlock()
#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000
static PyMutex __Pyx_ModuleStateLookup_mutex = {0};
#define __Pyx_ModuleStateLookup_Lock() PyMutex_Lock(&__Pyx_ModuleStateLookup_mutex)
#define __Pyx_ModuleStateLookup_Unlock() PyMutex_Unlock(&__Pyx_ModuleStateLookup_mutex)
#elif defined(__cplusplus) && __cplusplus >= 201103L
#include <mutex>
static std::mutex __Pyx_ModuleStateLookup_mutex;
#define __Pyx_ModuleStateLookup_Lock() __Pyx_ModuleStateLookup_mutex.lock()
#define __Pyx_ModuleStateLookup_Unlock() __Pyx_ModuleStateLookup_mutex.unlock()
#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ > 201112L) && !defined(__STDC_NO_THREADS__)
#include <threads.h>
static mtx_t __Pyx_ModuleStateLookup_mutex;
static once_flag __Pyx_ModuleStateLookup_mutex_once_flag = ONCE_FLAG_INIT;
static void __Pyx_ModuleStateLookup_initialize_mutex(void) {
    mtx_init(&__Pyx_ModuleStateLookup_mutex, mtx_plain);
}
#define __Pyx_ModuleStateLookup_Lock()\
  call_once(&__Pyx_ModuleStateLookup_mutex_once_flag, __Pyx_ModuleStateLookup_initialize_mutex);\
  mtx_lock(&__Pyx_ModuleStateLookup_mutex)
#define __Pyx_ModuleStateLookup_Unlock() mtx_unlock(&__Pyx_ModuleStateLookup_mutex)
#elif defined(HAVE_PTHREAD_H)
#include <pthread.h>
static pthread_mutex_t __Pyx_ModuleStateLookup_mutex = PTHREAD_MUTEX_INITIALIZER;
#define __Pyx_ModuleStateLookup_Lock() pthread_mutex_lock(&__Pyx_ModuleStateLookup_mutex)
#define __Pyx_ModuleStateLookup_Unlock() pthread_mutex_unlock(&__Pyx_ModuleStateLookup_mutex)
#elif defined(_WIN32)
#include <Windows.h>  // synchapi.h on its own doesn't work
static SRWLOCK __Pyx_ModuleStateLookup_mutex = SRWLOCK_INIT;
#define __Pyx_ModuleStateLookup_Lock() AcquireSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex)
#define __Pyx_ModuleStateLookup_Unlock() ReleaseSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex)
#else
#error "No suitable lock available for CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE.\
 Requires C standard >= C11, or C++ standard >= C++11,\
 or pthreads, or the Windows 32 API, or Python >= 3.13."
#endif
typedef struct {
    int64_t id;
    PyObject *module;
} __Pyx_InterpreterIdAndModule;
typedef struct {
    char interpreter_id_as_index;
    Py_ssize_t count;
    Py_ssize_t allocated;
    __Pyx_InterpreterIdAndModule table[1];
} __Pyx_ModuleStateLookupData;
#define __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE 32
#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
static __pyx_atomic_int_type __Pyx_ModuleStateLookup_read_counter = 0;
#endif
#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
static __pyx_atomic_ptr_type __Pyx_ModuleStateLookup_data = 0;
#else
static __Pyx_ModuleStateLookupData* __Pyx_ModuleStateLookup_data = NULL;
#endif
static __Pyx_InterpreterIdAndModule* __Pyx_State_FindModuleStateLookupTableLowerBound(
        __Pyx_InterpreterIdAndModule* table,
        Py_ssize_t count,
        int64_t interpreterId) {
    __Pyx_InterpreterIdAndModule* begin = table;
    __Pyx_InterpreterIdAndModule* end = begin + count;
    if (begin->id == interpreterId) {
        return begin;
    }
    while ((end - begin) > __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) {
        __Pyx_InterpreterIdAndModule* halfway = begin + (end - begin)/2;
        if (halfway->id == interpreterId) {
            return halfway;
        }
        if (halfway->id < interpreterId) {
            begin = halfway;
        } else {
            end = halfway;
        }
    }
    for (; begin < end; ++begin) {
        if (begin->id >= interpreterId) return begin;
    }
    return begin;
}
static PyObject *__Pyx_State_FindModule(CYTHON_UNUSED void* dummy) {
    int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get());
    if (interpreter_id == -1) return NULL;
#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
    __Pyx_ModuleStateLookupData* data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data);
    {
        __pyx_atomic_incr_acq_rel(&__Pyx_ModuleStateLookup_read_counter);
        if (likely(data)) {
            __Pyx_ModuleStateLookupData* new_data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_acquire(&__Pyx_ModuleStateLookup_data);
            if (likely(data == new_data)) {
                goto read_finished;
            }
        }
        __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter);
        __Pyx_ModuleStateLookup_Lock();
        __pyx_atomic_incr_relaxed(&__Pyx_ModuleStateLookup_read_counter);
        data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data);
        __Pyx_ModuleStateLookup_Unlock();
    }
  read_finished:;
#else
    __Pyx_ModuleStateLookupData* data = __Pyx_ModuleStateLookup_data;
#endif
    __Pyx_InterpreterIdAndModule* found = NULL;
    if (unlikely(!data)) goto end;
    if (data->interpreter_id_as_index) {
        if (interpreter_id < data->count) {
            found = data->table+interpreter_id;
        }
    } else {
        found = __Pyx_State_FindModuleStateLookupTableLowerBound(
            data->table, data->count, interpreter_id);
    }
  end:
    {
        PyObject *result=NULL;
        if (found && found->id == interpreter_id) {
            result = found->module;
        }
#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
        __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter);
#endif
        return result;
    }
}
#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
static void __Pyx_ModuleStateLookup_wait_until_no_readers(void) {
    while (__pyx_atomic_load(&__Pyx_ModuleStateLookup_read_counter) != 0);
}
#else
#define __Pyx_ModuleStateLookup_wait_until_no_readers()
#endif
static int __Pyx_State_AddModuleInterpIdAsIndex(__Pyx_ModuleStateLookupData **old_data, PyObject* module, int64_t interpreter_id) {
    Py_ssize_t to_allocate = (*old_data)->allocated;
    while (to_allocate <= interpreter_id) {
        if (to_allocate == 0) to_allocate = 1;
        else to_allocate *= 2;
    }
    __Pyx_ModuleStateLookupData *new_data = *old_data;
    if (to_allocate != (*old_data)->allocated) {
         new_data = (__Pyx_ModuleStateLookupData *)realloc(
            *old_data,
            sizeof(__Pyx_ModuleStateLookupData)+(to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule));
        if (!new_data) {
            PyErr_NoMemory();
            return -1;
        }
        for (Py_ssize_t i = new_data->allocated; i < to_allocate; ++i) {
            new_data->table[i].id = i;
            new_data->table[i].module = NULL;
        }
        new_data->allocated = to_allocate;
    }
    new_data->table[interpreter_id].module = module;
    if (new_data->count < interpreter_id+1) {
        new_data->count = interpreter_id+1;
    }
    *old_data = new_data;
    return 0;
}
static void __Pyx_State_ConvertFromInterpIdAsIndex(__Pyx_ModuleStateLookupData *data) {
    __Pyx_InterpreterIdAndModule *read = data->table;
    __Pyx_InterpreterIdAndModule *write = data->table;
    __Pyx_InterpreterIdAndModule *end = read + data->count;
    for (; read<end; ++read) {
        if (read->module) {
            write->id = read->id;
            write->module = read->module;
            ++write;
        }
    }
    data->count = write - data->table;
    for (; write<end; ++write) {
        write->id = 0;
        write->module = NULL;
    }
    data->interpreter_id_as_index = 0;
}
static int __Pyx_State_AddModule(PyObject* module, CYTHON_UNUSED void* dummy) {
    int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get());
    if (interpreter_id == -1) return -1;
    int result = 0;
    __Pyx_ModuleStateLookup_Lock();
#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
    __Pyx_ModuleStateLookupData *old_data = (__Pyx_ModuleStateLookupData *)
            __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0);
#else
    __Pyx_ModuleStateLookupData *old_data = __Pyx_ModuleStateLookup_data;
#endif
    __Pyx_ModuleStateLookupData *new_data = old_data;
    if (!new_data) {
        new_data = (__Pyx_ModuleStateLookupData *)calloc(1, sizeof(__Pyx_ModuleStateLookupData));
        if (!new_data) {
            result = -1;
            PyErr_NoMemory();
            goto end;
        }
        new_data->allocated = 1;
        new_data->interpreter_id_as_index = 1;
    }
    __Pyx_ModuleStateLookup_wait_until_no_readers();
    if (new_data->interpreter_id_as_index) {
        if (interpreter_id < __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) {
            result = __Pyx_State_AddModuleInterpIdAsIndex(&new_data, module, interpreter_id);
            goto end;
        }
        __Pyx_State_ConvertFromInterpIdAsIndex(new_data);
    }
    {
        Py_ssize_t insert_at = 0;
        {
            __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound(
                new_data->table, new_data->count, interpreter_id);
            assert(lower_bound);
            insert_at = lower_bound - new_data->table;
            if (unlikely(insert_at < new_data->count && lower_bound->id == interpreter_id)) {
                lower_bound->module = module;
                goto end;  // already in table, nothing more to do
            }
        }
        if (new_data->count+1 >= new_data->allocated) {
            Py_ssize_t to_allocate = (new_data->count+1)*2;
            new_data =
                (__Pyx_ModuleStateLookupData*)realloc(
                    new_data,
                    sizeof(__Pyx_ModuleStateLookupData) +
                    (to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule));
            if (!new_data) {
                result = -1;
                new_data = old_data;
                PyErr_NoMemory();
                goto end;
            }
            new_data->allocated = to_allocate;
        }
        ++new_data->count;
        int64_t last_id = interpreter_id;
        PyObject *last_module = module;
        for (Py_ssize_t i=insert_at; i<new_data->count; ++i) {
            int64_t current_id = new_data->table[i].id;
            new_data->table[i].id = last_id;
            last_id = current_id;
            PyObject *current_module = new_data->table[i].module;
            new_data->table[i].module = last_module;
            last_module = current_module;
        }
    }
  end:
#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
    __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, new_data);
#else
    __Pyx_ModuleStateLookup_data = new_data;
#endif
    __Pyx_ModuleStateLookup_Unlock();
    return result;
}
static int __Pyx_State_RemoveModule(CYTHON_UNUSED void* dummy) {
    int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get());
    if (interpreter_id == -1) return -1;
    __Pyx_ModuleStateLookup_Lock();
#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
    __Pyx_ModuleStateLookupData *data = (__Pyx_ModuleStateLookupData *)
            __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0);
#else
    __Pyx_ModuleStateLookupData *data = __Pyx_ModuleStateLookup_data;
#endif
    if (data->interpreter_id_as_index) {
        if (interpreter_id < data->count) {
            data->table[interpreter_id].module = NULL;
        }
        goto done;
    }
    {
        __Pyx_ModuleStateLookup_wait_until_no_readers();
        __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound(
            data->table, data->count, interpreter_id);
        if (!lower_bound) goto done;
        if (lower_bound->id != interpreter_id) goto done;
        __Pyx_InterpreterIdAndModule *end = data->table+data->count;
        for (;lower_bound<end-1; ++lower_bound) {
            lower_bound->id = (lower_bound+1)->id;
            lower_bound->module = (lower_bound+1)->module;
        }
    }
    --data->count;
    if (data->count == 0) {
        free(data);
        data = NULL;
    }
  done:
#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
    __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, data);
#else
    __Pyx_ModuleStateLookup_data = data;
#endif
    __Pyx_ModuleStateLookup_Unlock();
    return 0;
}
#endif

/* #### Code section: utility_code_pragmas_end ### */
#ifdef _MSC_VER
#pragma warning( pop )
#endif



/* #### Code section: end ### */
#endif /* Py_PYTHON_H */
